Anoubis Version: anoubis.0.9.5.27.73.234 Head of the Anoubis Branch: 08978ef43c5102268822a3a28f2ea09bdf4cef82 Masterhead of the diff: 381d0eed28b42f66912eac9aa40e95f23f5bcbc8 Upstream Commit Message: tree 449cf0ab3ee374eb9ccac794ef46da8228a5267b parent fbbe16fa4adc582b97000f561f563e47d53aa5b6 author root 1246481159 +0200 committer root 1246481159 +0200 AUTOMATIC UPDATE FROM CVS AT Wed Jul 1 22:45:57 CEST 2009 Note that the date given above is simply the time of the git commit. If the CVS repository was outdated this may not reflect the official state of the CVS at that time. diff --git a/bin/Makefile b/bin/Makefile index 30f28fa..28ece5b 100644 --- a/bin/Makefile +++ b/bin/Makefile @@ -1,8 +1,8 @@ # $OpenBSD: deraadt $ SUBDIR= cat chio chmod cp csh date dd df domainname echo \ - ed expr hostname kill ksh ln ls md5 mkdir mt \ - mv pax ps pwd rcp rm rmail rmdir sleep stty \ + ed expr getfacl hostname kill ksh ln ls md5 mkdir mt \ + mv pax ps pwd rcp rm rmail rmdir setfacl sleep stty \ sync systrace test .include diff --git a/bin/getfacl/Makefile b/bin/getfacl/Makefile new file mode 100644 index 0000000..7e20d95 --- /dev/null +++ b/bin/getfacl/Makefile @@ -0,0 +1,5 @@ +# $FreeBSD: Makefile,v 1.6 2001/12/04 01:57:44 obrien Exp $ + +PROG= getfacl + +.include diff --git a/bin/getfacl/getfacl.1 b/bin/getfacl/getfacl.1 new file mode 100644 index 0000000..c5e1da3 --- /dev/null +++ b/bin/getfacl/getfacl.1 @@ -0,0 +1,118 @@ +.\" +.\" Copyright (c) 2000, 2001, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: getfacl.1,v 1.11 2006/09/17 17:40:06 ru Exp $ +.\" +.Dd March 13, 2006 +.Dt GETFACL 1 +.Os +.Sh NAME +.Nm getfacl +.Nd get ACL information +.Sh SYNOPSIS +.Nm +.Op Fl dhq +.Op Ar +.Sh DESCRIPTION +The +.Nm +utility writes discretionary access control information associated with +the specified file(s) to standard output. +If the +.Xr getconf 1 +utility indicates that +.Eq { } Va _POSIX_ACL_EXTENDED +is not in effect for a +.Ar file +then the standard discretionary access permissions are interpreted as +an ACL containing only the required ACL entries. +.Pp +The following option is available: +.Bl -tag -width indent +.It Fl d +The operation applies to the default ACL of a directory instead of the +access ACL. +An error is generated if a default ACL cannot be associated with +.Ar file . +.It Fl h +If the target of the operation is a symbolic link, return the ACL from +the symbolic link itself rather than following the link. +.It Fl q +Do not write commented information about file name and ownership. +This is +useful when dealing with filenames with unprintable characters. +.El +.Pp +The following operand is available: +.Bl -tag -width indent +.It Ar file +A pathname of a file whose ACL shall be retrieved. +If +.Ar file +is not specified, or a +.Ar file +is specified as +.Fl , +then +.Nm +reads a list of pathnames, each terminated by one newline character, +from the standard input. +.El +.Sh EXIT STATUS +.Ex -std +.Sh EXAMPLES +.Dl getfacl / +.Pp +Retrieve ACL for the directory +.Pa / . +.Pp +.Dl getfacl -d / +.Pp +Retrieve the default ACL for the directory +.Pa / , +if any. +.Sh SEE ALSO +.Xr setfacl 1 , +.Xr acl 3 , +.Xr getextattr 8 , +.Xr setextattr 8 , +.Xr acl 9 , +.Xr extattr 9 +.Sh STANDARDS +The +.Nm +utility is expected to be +.Tn IEEE +Std 1003.2c compliant. +.Sh HISTORY +Extended Attribute and Access Control List support was developed as part +of the +.Tn TrustedBSD +Project and introduced in +.Fx 5.0 . +.Sh AUTHORS +.An Robert N M Watson diff --git a/bin/getfacl/getfacl.c b/bin/getfacl/getfacl.c new file mode 100644 index 0000000..57f112f --- /dev/null +++ b/bin/getfacl/getfacl.c @@ -0,0 +1,321 @@ +/* + * Copyright (c) 1999, 2001, 2002 Robert N M Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: getfacl.c,v 1.12 2007/09/19 02:04:47 kevlo Exp $ + */ + +/* + * getfacl -- POSIX.1e utility to extract ACLs from files and directories + * and send the results to stdout + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +int more_than_one = 0; + +static void +usage(void) +{ + fprintf(stderr, "getfacl [-dhq] [file ...]\n"); +} + +static char * +getuname(uid_t uid) +{ + struct passwd *pw; + static char uids[10]; + + if ((pw = getpwuid(uid)) == NULL) { + (void) snprintf(uids, sizeof(uids), "%u", uid); + return (uids); + } else + return (pw->pw_name); +} + +static char * +getgname(gid_t gid) +{ + struct group *gr; + static char gids[10]; + + if ((gr = getgrgid(gid)) == NULL) { + (void) snprintf(gids, sizeof(gids), "%u", gid); + return (gids); + } else + return (gr->gr_name); +} + +/* + * return an ACL corresponding to the permissions + * contained in struct stat + */ +static acl_t +acl_from_stat(struct stat sb) +{ + acl_t acl; + acl_entry_t entry; + acl_permset_t perms; + + /* create the ACL */ + acl = acl_init(3); + if (!acl) + return (NULL); + + /* First entry: ACL_USER_OBJ */ + + if (acl_create_entry(&acl, &entry) == -1) + return (NULL); + + if (acl_set_tag_type(entry, ACL_USER_OBJ) == -1) + return (NULL); + + if (acl_get_permset(entry, &perms) == -1) + return (NULL); + + if (acl_clear_perms(perms) == -1) + return (NULL); + + /* calculate user mode */ + + if (sb.st_mode & S_IRUSR) + if (acl_add_perm(perms, ACL_READ) == -1) + return (NULL); + + if (sb.st_mode & S_IWUSR) + if (acl_add_perm(perms, ACL_WRITE) == -1) + return (NULL); + + if (sb.st_mode & S_IXUSR) + if (acl_add_perm(perms, ACL_EXECUTE) == -1) + return (NULL); + + if (acl_set_permset(entry, perms) == -1) + return (NULL); + + /* Second entry: ACL_GROUP_OBJ */ + + if (acl_create_entry(&acl, &entry) == -1) + return (NULL); + + if (acl_set_tag_type(entry, ACL_GROUP_OBJ) == -1) + return (NULL); + + if (acl_get_permset(entry, &perms) == -1) + return (NULL); + + if (acl_clear_perms(perms) == -1) + return (NULL); + + /* calculate group mode */ + + if (sb.st_mode & S_IRGRP) + if (acl_add_perm(perms, ACL_READ) == -1) + return (NULL); + + if (sb.st_mode & S_IWGRP) + if (acl_add_perm(perms, ACL_WRITE) == -1) + return (NULL); + + if (sb.st_mode & S_IXGRP) + if (acl_add_perm(perms, ACL_EXECUTE) == -1) + return (NULL); + + if (acl_set_permset(entry, perms) == -1) + return (NULL); + + /* Third entry: ACL_OTHER */ + + if (acl_create_entry(&acl, &entry) == -1) + return (NULL); + + if (acl_set_tag_type(entry, ACL_OTHER) == -1) + return (NULL); + + if (acl_get_permset(entry, &perms) == -1) + return (NULL); + + if (acl_clear_perms(perms) == -1) + return (NULL); + + /* calculate other mode */ + + if (sb.st_mode & S_IROTH) + if (acl_add_perm(perms, ACL_READ) == -1) + return (NULL); + + if (sb.st_mode & S_IWOTH) + if (acl_add_perm(perms, ACL_WRITE) == -1) + return (NULL); + + if (sb.st_mode & S_IXOTH) + if (acl_add_perm(perms, ACL_EXECUTE) == -1) + return (NULL); + + if (acl_set_permset(entry, perms) == -1) + return (NULL); + + return (acl); +} + +static int +print_acl(char *path, acl_type_t type, int hflag, int qflag) +{ + struct stat sb; + acl_t acl; + char *acl_text; + int error; + + if (hflag) + error = lstat(path, &sb); + else + error = stat(path, &sb); + + if (error == -1) { + warn("%s", path); + return (-1); + } + + if (more_than_one) + printf("\n"); + else + more_than_one++; + + if (!qflag) + printf("# file: %s\n# owner: %s\n# group: %s\n", path, + getuname(sb.st_uid), getgname(sb.st_gid)); + + if (hflag) + acl = acl_get_link_np(path, type); + else + acl = acl_get_file(path, type); + + if (!acl) { + if (errno != EOPNOTSUPP) { + warn("%s", path); + return (-1); + } + errno = 0; + if (type != ACL_TYPE_ACCESS) + return (0); + acl = acl_from_stat(sb); + if (!acl) { + warn("acl_from_stat()"); + return (-1); + } + } + + acl_text = acl_to_text(acl, 0); + if (!acl_text) { + warn("%s", path); + return (-1); + } + + printf("%s", acl_text); + + (void) acl_free(acl); + (void) acl_free(acl_text); + + return (0); +} + +static int +print_acl_from_stdin(acl_type_t type, int hflag, int qflag) +{ + char *p, pathname[PATH_MAX]; + int carried_error = 0; + + while (fgets(pathname, (int)sizeof(pathname), stdin)) { + if ((p = strchr(pathname, '\n')) != NULL) + *p = '\0'; + if (print_acl(pathname, type, hflag, qflag) == -1) { + carried_error = -1; + } + } + + return (carried_error); +} + +int +main(int argc, char *argv[]) +{ + acl_type_t type = ACL_TYPE_ACCESS; + int carried_error = 0; + int ch, error, i; + int hflag, qflag; + + hflag = 0; + qflag = 0; + + while ((ch = getopt(argc, argv, "dhq")) != -1) + switch(ch) { + case 'd': + type = ACL_TYPE_DEFAULT; + break; + case 'h': + hflag = 1; + break; + case 'q': + qflag = 1; + break; + default: + usage(); + return (-1); + } + + argc -= optind; + argv += optind; + + if (argc == 0) { + error = print_acl_from_stdin(type, hflag, qflag); + return (error ? 1 : 0); + } + + for (i = 0; i < argc; i++) { + if (!strcmp(argv[i], "-")) { + error = print_acl_from_stdin(type, hflag, qflag); + if (error == -1) + carried_error = -1; + } else { + error = print_acl(argv[i], type, hflag, qflag); + if (error == -1) + carried_error = -1; + } + } + + return (carried_error ? 1 : 0); +} diff --git a/bin/setfacl/Makefile b/bin/setfacl/Makefile new file mode 100644 index 0000000..ec66fef --- /dev/null +++ b/bin/setfacl/Makefile @@ -0,0 +1,6 @@ +# $FreeBSD: Makefile,v 1.8 2004/06/13 19:22:53 obrien Exp $ + +PROG= setfacl +SRCS= file.c mask.c merge.c remove.c setfacl.c util.c + +.include diff --git a/bin/setfacl/file.c b/bin/setfacl/file.c new file mode 100644 index 0000000..fe10c53 --- /dev/null +++ b/bin/setfacl/file.c @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: file.c,v 1.5 2005/01/10 08:39:25 imp Exp $ + */ + +#include +#include + +#include +#include +#include + +#include "setfacl.h" + +/* + * read acl text from a file and return the corresponding acl + */ +acl_t +get_acl_from_file(const char *filename) +{ + FILE *file; + char buf[BUFSIZ]; + + if (filename == NULL) + err(1, "(null) filename in get_acl_from_file()"); + + bzero(&buf, sizeof(buf)); + + if (strcmp(filename, "-") == 0) { + if (have_stdin != 0) + err(1, "cannot specify more than one stdin"); + file = stdin; + have_stdin = 1; + } else { + file = fopen(filename, "r"); + if (file == NULL) + err(1, "fopen() %s failed", filename); + } + + fread(buf, sizeof(buf), (size_t)1, file); + if (ferror(file) != 0) { + fclose(file); + err(1, "error reading from %s", filename); + } else if (feof(file) == 0) { + fclose(file); + errx(1, "line too long in %s", filename); + } + + fclose(file); + + return (acl_from_text(buf)); +} diff --git a/bin/setfacl/mask.c b/bin/setfacl/mask.c new file mode 100644 index 0000000..1474f77 --- /dev/null +++ b/bin/setfacl/mask.c @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: mask.c,v 1.8 2005/01/10 08:39:25 imp Exp $ + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include "setfacl.h" + +/* set the appropriate mask the given ACL's */ +int +set_acl_mask(acl_t *prev_acl) +{ + acl_entry_t entry; + acl_t acl; + acl_tag_t tag; + int entry_id; + + entry = NULL; + + /* + * ... if a mask entry is specified, then the permissions of the mask + * entry in the resulting ACL shall be set to the permissions in the + * specified ACL mask entry. + */ + if (have_mask) + return (0); + + acl = acl_dup(*prev_acl); + if (acl == NULL) + err(1, "acl_dup() failed"); + + if (n_flag == 0) { + /* + * If no mask entry is specified and the -n option is not + * specified, then the permissions of the resulting ACL mask + * entry shall be set to the union of the permissions + * associated with all entries which belong to the file group + * class in the resulting ACL + */ + if (acl_calc_mask(&acl)) { + warn("acl_calc_mask() failed"); + acl_free(acl); + return (-1); + } + } else { + /* + * If no mask entry is specified and the -n option is + * specified, then the permissions of the resulting ACL + * mask entry shall remain unchanged ... + */ + + entry_id = ACL_FIRST_ENTRY; + + while (acl_get_entry(acl, entry_id, &entry) == 1) { + entry_id = ACL_NEXT_ENTRY; + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed"); + + if (tag == ACL_MASK) { + acl_free(acl); + return (0); + } + } + + /* + * If no mask entry is specified, the -n option is specified, + * and no ACL mask entry exists in the ACL associated with the + * file, then write an error message to standard error and + * continue with the next file. + */ + warnx("warning: no mask entry"); + acl_free(acl); + return (0); + } + + acl_free(*prev_acl); + *prev_acl = acl_dup(acl); + acl_free(acl); + + return (0); +} diff --git a/bin/setfacl/merge.c b/bin/setfacl/merge.c new file mode 100644 index 0000000..c1a2318 --- /dev/null +++ b/bin/setfacl/merge.c @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: merge.c,v 1.8 2005/01/10 08:39:25 imp Exp $ + */ + +#include +#include +#include + +#include +#include + +#include "setfacl.h" + +static int merge_user_group(acl_entry_t *, acl_entry_t *); + +static int +merge_user_group(acl_entry_t *entry, acl_entry_t *entry_new) +{ + acl_permset_t permset; + int have_entry; + uid_t *id, *id_new; + + have_entry = 0; + + id = acl_get_qualifier(*entry); + if (id == NULL) + err(1, "acl_get_qualifier() failed"); + + id_new = acl_get_qualifier(*entry_new); + if (id_new == NULL) + err(1, "acl_get_qualifier() failed"); + + if (*id == *id_new) { + /* any other matches */ + if (acl_get_permset(*entry, &permset) == -1) + err(1, "acl_get_permset() failed"); + if (acl_set_permset(*entry_new, permset) == -1) + err(1, "acl_set_permset() failed"); + have_entry = 1; + } + + acl_free(id); + acl_free(id_new); + + return (have_entry); +} + +/* + * merge an ACL into existing file's ACL + */ +int +merge_acl(acl_t acl, acl_t *prev_acl) +{ + acl_entry_t entry, entry_new; + acl_permset_t permset; + acl_t acl_new; + acl_tag_t tag, tag_new; + int entry_id, entry_id_new, have_entry; + + if (acl_type == ACL_TYPE_ACCESS) + acl_new = acl_dup(prev_acl[ACCESS_ACL]); + else + acl_new = acl_dup(prev_acl[DEFAULT_ACL]); + + if (acl_new == NULL) + err(1, "acl_dup() failed"); + + entry_id = ACL_FIRST_ENTRY; + + while (acl_get_entry(acl, entry_id, &entry) == 1) { + entry_id = ACL_NEXT_ENTRY; + have_entry = 0; + + /* keep track of existing ACL_MASK entries */ + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed - invalid ACL entry"); + if (tag == ACL_MASK) + have_mask = 1; + + /* check against the existing ACL entries */ + entry_id_new = ACL_FIRST_ENTRY; + while (have_entry == 0 && + acl_get_entry(acl_new, entry_id_new, &entry_new) == 1) { + entry_id_new = ACL_NEXT_ENTRY; + + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed"); + if (acl_get_tag_type(entry_new, &tag_new) == -1) + err(1, "acl_get_tag_type() failed"); + if (tag != tag_new) + continue; + + switch(tag) { + case ACL_USER: + case ACL_GROUP: + have_entry = merge_user_group(&entry, + &entry_new); + if (have_entry == 0) + break; + /* FALLTHROUGH */ + case ACL_USER_OBJ: + case ACL_GROUP_OBJ: + case ACL_OTHER: + case ACL_MASK: + if (acl_get_permset(entry, &permset) == -1) + err(1, "acl_get_permset() failed"); + if (acl_set_permset(entry_new, permset) == -1) + err(1, "acl_set_permset() failed"); + have_entry = 1; + break; + default: + /* should never be here */ + errx(1, "Invalid tag type: %i", tag); + break; + } + } + + /* if this entry has not been found, it must be new */ + if (have_entry == 0) { + if (acl_create_entry(&acl_new, &entry_new) == -1) { + acl_free(acl_new); + return (-1); + } + if (acl_copy_entry(entry_new, entry) == -1) + err(1, "acl_copy_entry() failed"); + } + } + + if (acl_type == ACL_TYPE_ACCESS) { + acl_free(prev_acl[ACCESS_ACL]); + prev_acl[ACCESS_ACL] = acl_new; + } else { + acl_free(prev_acl[DEFAULT_ACL]); + prev_acl[DEFAULT_ACL] = acl_new; + } + + return (0); +} diff --git a/bin/setfacl/remove.c b/bin/setfacl/remove.c new file mode 100644 index 0000000..2e90688 --- /dev/null +++ b/bin/setfacl/remove.c @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: remove.c,v 1.6 2005/01/10 08:39:25 imp Exp $ + */ + +#include +#include +#include + +#include +#include +#include + +#include "setfacl.h" + +/* + * remove ACL entries from an ACL + */ +int +remove_acl(acl_t acl, acl_t *prev_acl) +{ + acl_entry_t entry; + acl_t acl_new; + acl_tag_t tag; + int carried_error, entry_id; + + carried_error = 0; + + if (acl_type == ACL_TYPE_ACCESS) + acl_new = acl_dup(prev_acl[ACCESS_ACL]); + else + acl_new = acl_dup(prev_acl[DEFAULT_ACL]); + + if (acl_new == NULL) + err(1, "acl_dup() failed"); + + tag = ACL_UNDEFINED_TAG; + + /* find and delete the entry */ + entry_id = ACL_FIRST_ENTRY; + while (acl_get_entry(acl, entry_id, &entry) == 1) { + entry_id = ACL_NEXT_ENTRY; + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed"); + if (tag == ACL_MASK) + have_mask++; + if (acl_delete_entry(acl_new, entry) == -1) { + carried_error++; + warnx("cannot remove non-existent acl entry"); + } + } + + if (acl_type == ACL_TYPE_ACCESS) { + acl_free(prev_acl[ACCESS_ACL]); + prev_acl[ACCESS_ACL] = acl_new; + } else { + acl_free(prev_acl[DEFAULT_ACL]); + prev_acl[DEFAULT_ACL] = acl_new; + } + + if (carried_error) + return (-1); + + return (0); +} + +/* + * remove default entries + */ +int +remove_default(acl_t *prev_acl) +{ + if (prev_acl[1]) { + acl_free(prev_acl[1]); + prev_acl[1] = acl_init(ACL_MAX_ENTRIES); + if (prev_acl[1] == NULL) + err(1, "acl_init() failed"); + } else { + warn("cannot remove default ACL"); + return (-1); + } + + return (0); +} + +/* + * remove extended entries + */ +void +remove_ext(acl_t *prev_acl) +{ + acl_t acl_new, acl_old; + acl_entry_t entry, entry_new; + acl_permset_t perm; + acl_tag_t tag; + int entry_id, have_mask_entry; + + if (acl_type == ACL_TYPE_ACCESS) + acl_old = acl_dup(prev_acl[ACCESS_ACL]); + else + acl_old = acl_dup(prev_acl[DEFAULT_ACL]); + + if (acl_old == NULL) + err(1, "acl_dup() failed"); + + have_mask_entry = 0; + acl_new = acl_init(ACL_MAX_ENTRIES); + if (acl_new == NULL) + err(1, "acl_init() failed"); + + tag = ACL_UNDEFINED_TAG; + + /* only save the default user/group/other entries */ + entry_id = ACL_FIRST_ENTRY; + while (acl_get_entry(acl_old, entry_id, &entry) == 1) { + entry_id = ACL_NEXT_ENTRY; + + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed"); + + switch(tag) { + case ACL_USER_OBJ: + case ACL_GROUP_OBJ: + case ACL_OTHER: + if (acl_get_tag_type(entry, &tag) == -1) + err(1, "acl_get_tag_type() failed"); + if (acl_get_permset(entry, &perm) == -1) + err(1, "acl_get_permset() failed"); + if (acl_create_entry(&acl_new, &entry_new) == -1) + err(1, "acl_create_entry() failed"); + if (acl_set_tag_type(entry_new, tag) == -1) + err(1, "acl_set_tag_type() failed"); + if (acl_set_permset(entry_new, perm) == -1) + err(1, "acl_get_permset() failed"); + if (acl_copy_entry(entry_new, entry) == -1) + err(1, "acl_copy_entry() failed"); + break; + case ACL_MASK: + have_mask_entry = 1; + break; + default: + break; + } + } + if (have_mask_entry && n_flag == 0) { + if (acl_calc_mask(&acl_new) == -1) + err(1, "acl_calc_mask() failed"); + } else { + have_mask = 1; + } + + if (acl_type == ACL_TYPE_ACCESS) { + acl_free(prev_acl[ACCESS_ACL]); + prev_acl[ACCESS_ACL] = acl_new; + } else { + acl_free(prev_acl[DEFAULT_ACL]); + prev_acl[DEFAULT_ACL] = acl_new; + } +} diff --git a/bin/setfacl/setfacl.1 b/bin/setfacl/setfacl.1 new file mode 100644 index 0000000..f7e81e4 --- /dev/null +++ b/bin/setfacl/setfacl.1 @@ -0,0 +1,296 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: setfacl.1,v 1.17 2006/09/17 17:40:07 ru Exp $ +.\" +.Dd January 7, 2001 +.Dt SETFACL 1 +.Os +.Sh NAME +.Nm setfacl +.Nd set ACL information +.Sh SYNOPSIS +.Nm +.Op Fl bdhkn +.Op Fl m Ar entries +.Op Fl M Ar file +.Op Fl x Ar entries +.Op Fl X Ar file +.Op Ar +.Sh DESCRIPTION +The +.Nm +utility sets discretionary access control information on +the specified file(s). +If no files are specified, or the list consists of the only +.Sq Fl , +the file names are taken from the standard input. +.Pp +The following options are available: +.Bl -tag -width indent +.It Fl b +Remove all ACL entries except for the three required entries. +If the ACL contains a +.Dq Li mask +entry, the permissions of the +.Dq Li group +entry in the resulting ACL will be set to the permission +associated with both the +.Dq Li group +and +.Dq Li mask +entries of the current ACL. +.It Fl d +The operations apply to the default ACL entries instead of +access ACL entries. +Currently only directories may have +default ACL's. +.It Fl h +If the target of the operation is a symbolic link, perform the operation +on the symbolic link itself, rather than following the link. +.It Fl k +Delete any default ACL entries on the specified files. +It +is not considered an error if the specified files do not have +any default ACL entries. +An error will be reported if any of +the specified files cannot have a default entry (i.e.\& +non-directories). +.It Fl m Ar entries +Modify the ACL entries on the specified files by adding new +entries and modifying existing ACL entries with the ACL entries +specified in +.Ar entries . +.It Fl M Ar file +Modify the ACL entries on the specified files by adding new +ACL entries and modifying existing ACL entries with the ACL +entries specified in the file +.Ar file . +If +.Ar file +is +.Fl , +the input is taken from stdin. +.It Fl n +Do not recalculate the permissions associated with the ACL +mask entry. +.It Fl x Ar entries +Remove the ACL entries specified in +.Ar entries +from the access or default ACL of the specified files. +.It Fl X Ar file +Remove the ACL entries specified in the file +.Ar file +from the access or default ACL of the specified files. +.El +.Pp +The above options are evaluated in the order specified +on the command-line. +.Sh ACL ENTRIES +An ACL entry contains three colon-separated fields: +an ACL tag, an ACL qualifier, and discretionary access +permissions: +.Bl -tag -width indent +.It Ar "ACL tag" +The ACL tag specifies the ACL entry type and consists of +one of the following: +.Dq Li user +or +.Ql u +specifying the access +granted to the owner of the file or a specified user; +.Dq Li group +or +.Ql g +specifying the access granted to the file owning group +or a specified group; +.Dq Li other +or +.Ql o +specifying the access +granted to any process that does not match any user or group +ACL entry; +.Dq Li mask +or +.Ql m +specifying the maximum access +granted to any ACL entry except the +.Dq Li user +ACL entry for the file owner and the +.Dq Li other +ACL entry. +.It Ar "ACL qualifier" +The ACL qualifier field describes the user or group associated with +the ACL entry. +It may consist of one of the following: uid or +user name, gid or group name, or empty. +For +.Dq Li user +ACL entries, an empty field specifies access granted to the +file owner. +For +.Dq Li group +ACL entries, an empty field specifies access granted to the +file owning group. +.Dq Li mask +and +.Dq Li other +ACL entries do not use this field. +.It Ar "access permissions" +The access permissions field contains up to one of each of +the following: +.Ql r , +.Ql w , +and +.Ql x +to set read, write, and +execute permissions, respectively. +Each of these may be excluded +or replaced with a +.Ql - +character to indicate no access. +.El +.Pp +A +.Dq Li mask +ACL entry is required on a file with any ACL entries other than +the default +.Dq Li user , +.Dq Li group , +and +.Dq Li other +ACL entries. +If the +.Fl n +option is not specified and no +.Dq Li mask +ACL entry was specified, the +.Nm +utility +will apply a +.Dq Li mask +ACL entry consisting of the union of the permissions associated +with all +.Dq Li group +ACL entries in the resulting ACL. +.Pp +Traditional POSIX interfaces acting on file system object modes have +modified semantics in the presence of POSIX.1e extended ACLs. +When a mask entry is present on the access ACL of an object, the mask +entry is substituted for the group bits; this occurs in programs such +as +.Xr stat 1 +or +.Xr ls 1 . +When the mode is modified on an object that has a mask entry, the +changes applied to the group bits will actually be applied to the +mask entry. +These semantics provide for greater application compatibility: +applications modifying the mode instead of the ACL will see +conservative behavior, limiting the effective rights granted by all +of the additional user and group entries; this occurs in programs +such as +.Xr chmod 1 . +.Pp +ACL entries applied from a file using the +.Fl M +or +.Fl X +options shall be of the following form: one ACL entry per line, as +previously specified; whitespace is ignored; any text after a +.Ql # +is ignored (comments). +.Pp +When ACL entries are evaluated, the access check algorithm checks +the ACL entries in the following order: file owner, +.Dq Li user +ACL entries, file owning group, +.Dq Li group +ACL entries, and +.Dq Li other +ACL entry. +.Pp +Multiple ACL entries specified on the command line are +separated by commas. +.Sh EXIT STATUS +.Ex -std +.Sh EXAMPLES +.Dl setfacl -m u::rwx,g:mail:rw file +.Pp +Sets read, write, and execute permissions for the +.Pa file +owner's ACL entry and read and write permissions for group mail on +.Pa file . +.Pp +.Dl setfacl -M file1 file2 +.Pp +Sets/updates the ACL entries contained in +.Pa file1 +on +.Pa file2 . +.Pp +.Dl setfacl -x g:mail:rw file +.Pp +Remove the group mail ACL entry containing read/write permissions +from +.Pa file . +.Pp +.Dl setfacl -bn file +.Pp +Remove all +.Dq Li access +ACL entries except for the three required from +.Pa file . +.Pp +.Dl getfacl file1 | setfacl -b -n -M - file2 +.Pp +Copy ACL entries from +.Pa file1 +to +.Pa file2 . +.Sh SEE ALSO +.Xr getfacl 1 , +.Xr acl 3 , +.Xr getextattr 8 , +.Xr setextattr 8 , +.Xr acl 9 , +.Xr extattr 9 +.Sh STANDARDS +The +.Nm +utility is expected to be +.Tn IEEE +Std 1003.2c compliant. +.Sh HISTORY +Extended Attribute and Access Control List support was developed +as part of the +.Tn TrustedBSD +Project and introduced in +.Fx 5.0 . +.Sh AUTHORS +The +.Nm +utility was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/bin/setfacl/setfacl.c b/bin/setfacl/setfacl.c new file mode 100644 index 0000000..4c6cdaf --- /dev/null +++ b/bin/setfacl/setfacl.c @@ -0,0 +1,281 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: setfacl.c,v 1.13 2007/02/26 00:42:17 mckusick Exp $ + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "setfacl.h" + +static void add_filename(const char *); +static acl_t *get_file_acls(const char *); +static void usage(void); + +static void +add_filename(const char *filename) +{ + struct sf_file *file; + + if (strlen(filename) > PATH_MAX - 1) { + warn("illegal filename"); + return; + } + + file = zmalloc(sizeof(struct sf_file)); + file->filename = filename; + TAILQ_INSERT_TAIL(&filelist, file, next); +} + +static acl_t * +get_file_acls(const char *filename) +{ + acl_t *acl; + struct stat sb; + + if (stat(filename, &sb) == -1) { + warn("stat() of %s failed", filename); + return (NULL); + } + + acl = zmalloc(sizeof(acl_t) * 2); + if (h_flag) + acl[ACCESS_ACL] = acl_get_link_np(filename, ACL_TYPE_ACCESS); + else + acl[ACCESS_ACL] = acl_get_file(filename, ACL_TYPE_ACCESS); + + if (acl[ACCESS_ACL] == NULL) + err(1, "acl_get_file() failed"); + + if (S_ISDIR(sb.st_mode)) { + if (h_flag) + acl[DEFAULT_ACL] = acl_get_link_np(filename, + ACL_TYPE_DEFAULT); + else + acl[DEFAULT_ACL] = acl_get_file(filename, + ACL_TYPE_DEFAULT); + if (acl[DEFAULT_ACL] == NULL) + err(1, "acl_get_file() failed"); + } else + acl[DEFAULT_ACL] = NULL; + + return (acl); +} + +static void +usage(void) +{ + fprintf(stderr, "usage: setfacl [-bdhkn] [-m entries] [-M file] " + "[-x entries] [-X file] [file ...]\n"); + exit(1); +} + +int +main(int argc, char *argv[]) +{ + acl_t *acl, final_acl; + char filename[PATH_MAX]; + int local_error, carried_error, ch, i; + struct sf_file *file; + struct sf_entry *entry; + const char *fn_dup; + + acl_type = ACL_TYPE_ACCESS; + carried_error = local_error = 0; + h_flag = have_mask = have_stdin = n_flag = need_mask = 0; + + TAILQ_INIT(&entrylist); + TAILQ_INIT(&filelist); + + while ((ch = getopt(argc, argv, "M:X:bdhkm:nx:")) != -1) + switch(ch) { + case 'M': + entry = zmalloc(sizeof(struct sf_entry)); + entry->acl = get_acl_from_file(optarg); + if (entry->acl == NULL) + err(1, "get_acl_from_file() failed"); + entry->op = OP_MERGE_ACL; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + case 'X': + entry = zmalloc(sizeof(struct sf_entry)); + entry->acl = get_acl_from_file(optarg); + entry->op = OP_REMOVE_ACL; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + case 'b': + entry = zmalloc(sizeof(struct sf_entry)); + entry->op = OP_REMOVE_EXT; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + case 'd': + acl_type = ACL_TYPE_DEFAULT; + break; + case 'h': + h_flag = 1; + break; + case 'k': + entry = zmalloc(sizeof(struct sf_entry)); + entry->op = OP_REMOVE_DEF; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + case 'm': + entry = zmalloc(sizeof(struct sf_entry)); + entry->acl = acl_from_text(optarg); + if (entry->acl == NULL) + err(1, "%s", optarg); + entry->op = OP_MERGE_ACL; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + case 'n': + n_flag++; + break; + case 'x': + entry = zmalloc(sizeof(struct sf_entry)); + entry->acl = acl_from_text(optarg); + if (entry->acl == NULL) + err(1, "%s", optarg); + entry->op = OP_REMOVE_ACL; + TAILQ_INSERT_TAIL(&entrylist, entry, next); + break; + default: + usage(); + break; + } + + argc -= optind; + argv += optind; + + if (n_flag == 0 && TAILQ_EMPTY(&entrylist)) + usage(); + + /* take list of files from stdin */ + if (argc == 0 || strcmp(argv[0], "-") == 0) { + if (have_stdin) + err(1, "cannot have more than one stdin"); + have_stdin = 1; + bzero(&filename, sizeof(filename)); + while (fgets(filename, (int)sizeof(filename), stdin)) { + /* remove the \n */ + filename[strlen(filename) - 1] = '\0'; + fn_dup = strdup(filename); + if (fn_dup == NULL) + err(1, "strdup() failed"); + add_filename(fn_dup); + } + } else + for (i = 0; i < argc; i++) + add_filename(argv[i]); + + /* cycle through each file */ + TAILQ_FOREACH(file, &filelist, next) { + /* get our initial access and default ACL's */ + acl = get_file_acls(file->filename); + if (acl == NULL) + continue; + if ((acl_type == ACL_TYPE_DEFAULT) && !acl[1]) { + warnx("Default ACL not valid for %s", file->filename); + continue; + } + + local_error = 0; + + /* cycle through each option */ + TAILQ_FOREACH(entry, &entrylist, next) { + if (local_error) + continue; + + switch(entry->op) { + case OP_MERGE_ACL: + local_error += merge_acl(entry->acl, acl); + need_mask = 1; + break; + case OP_REMOVE_EXT: + remove_ext(acl); + need_mask = 0; + break; + case OP_REMOVE_DEF: + if (acl_delete_def_file(file->filename) == -1) { + warn("acl_delete_def_file() failed"); + local_error++; + } + local_error += remove_default(acl); + need_mask = 0; + break; + case OP_REMOVE_ACL: + local_error += remove_acl(entry->acl, acl); + need_mask = 1; + break; + } + } + + /* don't bother setting the ACL if something is broken */ + if (local_error) { + carried_error++; + continue; + } + + if (acl_type == ACL_TYPE_ACCESS) { + final_acl = acl[ACCESS_ACL]; + acl_free(acl[DEFAULT_ACL]); + } else { + final_acl = acl[DEFAULT_ACL]; + acl_free(acl[ACCESS_ACL]); + } + + if (need_mask && (set_acl_mask(&final_acl) == -1)) { + warnx("failed to set ACL mask on %s", file->filename); + carried_error++; + } else if (h_flag) { + if (acl_set_link_np(file->filename, acl_type, + final_acl) == -1) { + carried_error++; + warn("acl_set_link_np() failed for %s", + file->filename); + } + } else { + if (acl_set_file(file->filename, acl_type, + final_acl) == -1) { + carried_error++; + warn("acl_set_file() failed for %s", + file->filename); + } + } + + acl_free(final_acl); + free(acl); + } + + return (carried_error); +} diff --git a/bin/setfacl/setfacl.h b/bin/setfacl/setfacl.h new file mode 100644 index 0000000..b6523bc --- /dev/null +++ b/bin/setfacl/setfacl.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: setfacl.h,v 1.5 2005/01/10 08:39:25 imp Exp $ + */ + +#ifndef _SETFACL_H +#define _SETFACL_H + +#include +#include +#include + +/* file operations */ +#define OP_MERGE_ACL 0x00 /* merge acl's (-mM) */ +#define OP_REMOVE_DEF 0x01 /* remove default acl's (-k) */ +#define OP_REMOVE_EXT 0x02 /* remove extended acl's (-b) */ +#define OP_REMOVE_ACL 0x03 /* remove acl's (-xX) */ + +/* ACL types for the acl array */ +#define ACCESS_ACL 0 +#define DEFAULT_ACL 1 + +/* TAILQ entry for acl operations */ +struct sf_entry { + uint op; + acl_t acl; + TAILQ_ENTRY(sf_entry) next; +}; + +TAILQ_HEAD(, sf_entry) entrylist; + +/* TAILQ entry for files */ +struct sf_file { + const char *filename; + TAILQ_ENTRY(sf_file) next; +}; + +TAILQ_HEAD(, sf_file) filelist; + +/* files.c */ +acl_t get_acl_from_file(const char *); +/* merge.c */ +int merge_acl(acl_t, acl_t *); +/* remove.c */ +int remove_acl(acl_t, acl_t *); +int remove_default(acl_t *); +void remove_ext(acl_t *); +/* mask.c */ +int set_acl_mask(acl_t *); +/* util.c */ +void *zmalloc(size_t); + +acl_type_t acl_type; +uint have_mask; +uint need_mask; +uint have_stdin; +uint h_flag; +uint n_flag; + +#endif /* _SETFACL_H */ diff --git a/bin/setfacl/util.c b/bin/setfacl/util.c new file mode 100644 index 0000000..e6ad6a4 --- /dev/null +++ b/bin/setfacl/util.c @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2001 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: util.c,v 1.6 2005/01/10 08:39:25 imp Exp $ + */ + +#include +#include +#include + +#include "setfacl.h" + +void * +zmalloc(size_t size) +{ + void *ptr; + + ptr = calloc(1, size); + if (ptr == NULL) + err(1, "calloc() failed"); + + return (ptr); +} diff --git a/distrib/i386/Makefile b/distrib/i386/Makefile index 8ee4c53..3ad2f81 100644 --- a/distrib/i386/Makefile +++ b/distrib/i386/Makefile @@ -1,6 +1,6 @@ # $OpenBSD: deraadt $ -SUBDIR= ramdisk_cd ramdiskA ramdiskB ramdiskC cdfs cdfs-emu +SUBDIR= ramdisk_cd cdfs cdfs-emu .if make(obj) || make(cleandir) || make(clean) SUBDIR+= iso @@ -8,8 +8,5 @@ SUBDIR+= iso unconfig: cd ramdisk_cd; ${MAKE} unconfig - cd ramdiskA; ${MAKE} unconfig - cd ramdiskB; ${MAKE} unconfig - cd ramdiskC; ${MAKE} unconfig .include diff --git a/distrib/miniroot/install.sub b/distrib/miniroot/install.sub index 911c8aa..19984e6 100644 --- a/distrib/miniroot/install.sub +++ b/distrib/miniroot/install.sub @@ -1056,6 +1056,11 @@ install_files() { case $_f in *.tgz) ftp $FTPOPTS -o - -m "$_src/$_f" | \ $shacmd | tar zxphf - -C /mnt + # save the content of the distribution sets to a file + if [ $_f != "site$VERSION.tgz" ]; then + ftp $FTPOPTS -o - "$_src/$_f" | tar tfz - \ + >> /mnt/files_to_update + fi ;; *) ftp $FTPOPTS -o - -m "$_src/$_f" | \ $shacmd > "/mnt/$_f" diff --git a/distrib/sets/lists/base/mi.anoubis b/distrib/sets/lists/base/mi.anoubis new file mode 100644 index 0000000..68f10c0 --- /dev/null +++ b/distrib/sets/lists/base/mi.anoubis @@ -0,0 +1 @@ +./dev/MAKEDEV.local diff --git a/distrib/sets/makeflist b/distrib/sets/makeflist index dfd13d9..fb6c3b9 100644 --- a/distrib/sets/makeflist +++ b/distrib/sets/makeflist @@ -34,5 +34,6 @@ for i in base comp etc game; do done cat ./lists/man/mi ./lists/man/md.${arch} >> $TMP cat ./lists/misc/mi ./lists/misc/md.${arch} >> $TMP +cat ./lists/base/mi.anoubis >> $TMP sort $TMP diff --git a/distrib/sets/maketars b/distrib/sets/maketars index 6746eec..da55585 100644 --- a/distrib/sets/maketars +++ b/distrib/sets/maketars @@ -56,6 +56,7 @@ cd $fsdir for i in base comp etc game man misc; do echo -n "$i: " sort ${lists}/$i/mi ${lists}/$i/md.${arch} > $TMP + [ -f ${lists}/$i/mi.anoubis ] && sort ${lists}/$i/mi.anoubis >> $TMP cat $TMP | grep '^./usr/lib/lib' > $TMP2 cat $TMP | grep -v '^./usr/lib/lib' >> $TMP2 cat $TMP2 | pax -w -d | gzip > ${tardir}/$i${RELEASE}.tgz diff --git a/etc/MAKEDEV.local b/etc/MAKEDEV.local new file mode 100644 index 0000000..9ddc22f --- /dev/null +++ b/etc/MAKEDEV.local @@ -0,0 +1,40 @@ +#!/bin/sh +########################################################################### +# Copyright (c) 2009 GeNUA mbH +# +# 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 COPYRIGHT HOLDERS AND CONTRIBUTORS +# "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 COPYRIGHT +# OWNER OR CONTRIBUTORS 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. +########################################################################### + +# Anoubis device MAKEDEV script. + +PATH=/sbin:/bin:/usr/bin +major=90 + +for dev in eventdev anoubis; +do + if [ ! -e $dev ]; then + mknod -m 644 $dev c $major 0 + fi + major=$((++major)); +done diff --git a/etc/Makefile b/etc/Makefile index b9dda33..97f45b0 100644 --- a/etc/Makefile +++ b/etc/Makefile @@ -1,7 +1,7 @@ # $OpenBSD: ajacoutot $ TZDIR= /usr/share/zoneinfo -LOCALTIME= Canada/Mountain +LOCALTIME= Europe/Berlin NOOBJ= @@ -91,6 +91,8 @@ distribution-etc-root-var: distrib-dirs ${INSTALL} -c -o root -g wheel -m 600 snmpd.conf ${DESTDIR}/etc ${INSTALL} -c -o ${BINOWN} -g ${BINGRP} -m 555 \ etc.${MACHINE}/MAKEDEV ${DESTDIR}/dev + ${INSTALL} -c -o ${BINOWN} -g ${BINGRP} -m 555 \ + MAKEDEV.local ${DESTDIR}/dev cd root; \ ${INSTALL} -c -o root -g wheel -m 644 dot.cshrc \ ${DESTDIR}/root/.cshrc; \ diff --git a/etc/etc.i386/Makefile.inc b/etc/etc.i386/Makefile.inc index 6b36433..5f1bc83 100644 --- a/etc/etc.i386/Makefile.inc +++ b/etc/etc.i386/Makefile.inc @@ -25,7 +25,6 @@ linux-notes: cp ${.CURDIR}/etc.i386/INSTALL.* ${RELEASEDIR} MDEXT= bsd bsd.mp bsd.rd cd${OSrev}.iso cdemu${OSrev}.iso \ - floppy${OSrev}.fs floppyB${OSrev}.fs floppyC${OSrev}.fs \ pxeboot cdboot cdbr INSTALL.linux .PHONY: bsd bsd.mp bootblocks diff --git a/etc/rc b/etc/rc index 64039d9..41c99a5 100644 --- a/etc/rc +++ b/etc/rc @@ -346,6 +346,17 @@ if [ -d /var/empty ]; then fi syslogd ${syslogd_flags} +# upgrade /var/lib/anoubis/sfs if necessary +if [ -x /usr/local/share/anoubisd/upgrade_sfs.pl ]; then + /usr/local/share/anoubisd/upgrade_sfs.pl +fi + +# start anoubisd +if [ -x /sbin/anoubisd ]; then + echo ' anoubisd' + /sbin/anoubisd +fi + if [ X"${pf}" != X"NO" ]; then ifconfig pflog0 create >/dev/null 2>&1 if ifconfig pflog0 >/dev/null 2>&1; then diff --git a/include/protocols/dumprestore.h b/include/protocols/dumprestore.h index e06f41f..31f25f6 100644 --- a/include/protocols/dumprestore.h +++ b/include/protocols/dumprestore.h @@ -81,7 +81,8 @@ union u_spcl { struct ufs1_dinode __uc_dinode; struct { uint16_t __uc_mode; - int16_t __uc_spare1[3]; + int16_t __uc_spare1[1]; + int32_t __uc_extsize; uint64_t __uc_size; int32_t __uc_old_atime; int32_t __uc_atimensec; @@ -135,6 +136,7 @@ union u_spcl { #define c_file_flags __c_ino.__uc_ino.__uc_file_flags #define c_uid __c_ino.__uc_ino.__uc_uid #define c_gid __c_ino.__uc_ino.__uc_gid +#define c_extsize __c_ino.__uc_ino.__uc_extsize /* * special record types diff --git a/lib/libc/Makefile.inc b/lib/libc/Makefile.inc index 10e18bf..33e0f56 100644 --- a/lib/libc/Makefile.inc +++ b/lib/libc/Makefile.inc @@ -52,6 +52,7 @@ AINC+= -nostdinc -idirafter ${DESTDIR}/usr/include .include "${LIBCSRCDIR}/thread/Makefile.inc" .include "${LIBCSRCDIR}/time/Makefile.inc" .include "${LIBCSRCDIR}/sys/Makefile.inc" +.include "${LIBCSRCDIR}/posix1e/Makefile.inc" .if (${YP:L} == "yes") .include "${LIBCSRCDIR}/yp/Makefile.inc" .endif diff --git a/lib/libc/posix1e/Makefile.inc b/lib/libc/posix1e/Makefile.inc new file mode 100644 index 0000000..3e6c601 --- /dev/null +++ b/lib/libc/posix1e/Makefile.inc @@ -0,0 +1,86 @@ +# $FreeBSD: Makefile.inc,v 1.19 2006/07/07 14:02:17 rwatson Exp $ + +.PATH: ${.CURDIR}/posix1e + +SRCS+= acl_calc_mask.c \ + acl_copy.c \ + acl_delete.c \ + acl_delete_entry.c \ + acl_entry.c \ + acl_free.c \ + acl_from_text.c \ + acl_get.c \ + acl_init.c \ + acl_perm.c \ + acl_set.c \ + acl_support.c \ + acl_to_text.c \ + acl_valid.c \ + extattr.c \ + mac.c \ + mac_exec.c \ + mac_get.c \ + mac_set.c + +MAN+= acl.3 \ + acl_add_perm.3 \ + acl_calc_mask.3 \ + acl_clear_perms.3 \ + acl_copy_entry.3 \ + acl_create_entry.3 \ + acl_delete.3 \ + acl_delete_entry.3 \ + acl_delete_perm.3 \ + acl_dup.3 \ + acl_free.3 \ + acl_from_text.3 \ + acl_get.3 \ + acl_get_entry.3 \ + acl_get_permset.3 \ + acl_get_perm_np.3 \ + acl_get_qualifier.3 \ + acl_get_tag_type.3 \ + acl_init.3 \ + acl_set.3 \ + acl_set_permset.3 \ + acl_set_qualifier.3 \ + acl_set_tag_type.3 \ + acl_to_text.3 \ + acl_valid.3 \ + extattr.3 \ + mac.3 \ + mac.conf.5 \ + mac_free.3 \ + mac_is_present.3 \ + mac_get.3 \ + mac_prepare.3 \ + mac_set.3 \ + mac_text.3 + +MLINKS+=acl_delete.3 acl_delete_def_file.3 \ + acl_delete.3 acl_delete_file_np.3 \ + acl_delete.3 acl_delete_fd_np.3 \ + acl_get.3 acl_get_file.3 \ + acl_get.3 acl_get_fd.3 \ + acl_get.3 acl_get_fd_np.3 \ + acl_set.3 acl_set_file.3 \ + acl_set.3 acl_set_fd.3 \ + acl_set.3 acl_set_fd_np.3 \ + acl_valid.3 acl_valid_file_np.3 \ + acl_valid.3 acl_valid_fd_np.3 \ + extattr.3 extattr_namespace_to_string.3 \ + extattr.3 extattr_string_to_namespace.3 \ + mac_get.3 mac_get_fd.3 \ + mac_get.3 mac_get_file.3 \ + mac_get.3 mac_get_link.3 \ + mac_get.3 mac_get_pid.3 \ + mac_get.3 mac_get_proc.3 \ + mac_prepare.3 mac_prepare_file_label.3 \ + mac_prepare.3 mac_prepare_ifnet_label.3 \ + mac_prepare.3 mac_prepare_process_label.3 \ + mac_set.3 mac_set_link.3 \ + mac_set.3 mac_set_fd.3 \ + mac_set.3 mac_set_file.3 \ + mac_set.3 mac_set_proc.3 \ + mac_text.3 mac_from_text.3 \ + mac_text.3 mac_to_text.3 diff --git a/lib/libc/posix1e/acl.3 b/lib/libc/posix1e/acl.3 new file mode 100644 index 0000000..84eb5c9 --- /dev/null +++ b/lib/libc/posix1e/acl.3 @@ -0,0 +1,242 @@ +.\" +.\" Copyright (c) 2000, 2001, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl.3,v 1.22 2003/02/06 11:04:46 charnier Exp $ +.\" +.Dd December 18, 2002 +.Dt ACL 3 +.Os +.Sh NAME +.Nm acl +.Nd introduction to the POSIX.1e ACL security API +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Sh DESCRIPTION +.Fx +permits file systems to export Access Control Lists via the VFS, and +provides a library for userland access to and manipulation of these ACLs. +Not all file systems provide support for ACLs, and some may require that +ACL support be explicitly enabled by the administrator. +The library calls include routines to allocate, duplicate, retrieve, set, +and validate ACLs associated with file objects. +As well as the POSIX.1e routines, there are a number of non-portable +extensions defined that allow for alternative ACL semantics than the +POSIX.1e semantics, such as AFS, NTFS, Coda, and NWFS semantics. +Where routines are non-standard, they are suffixed with _np to indicate that +they are not portable. +.Pp +POSIX.1e describes a set of ACL manipulation routines to manage the +contents of ACLs, as well as their relationships with files; almost +all of these support routines are implemented in +.Fx . +.Pp +Available functions, sorted by behavior, include: +.Bl -tag -width indent +.It Fn acl_add_perm +This function is described in +.Xr acl_add_perm 3 , +and may be used to add permissions to a permission set. +.It Fn acl_calc_mask +This function is described in +.Xr acl_calc_mask 3 , +and may be used to calculate and set the permissions associated with +the +.Dv ACL_MASK +entry. +.It Fn acl_clear_perms +This function is described in +.Xr acl_clear_perms 3 , +and may be used to clear all permissions from a permission set. +.It Fn acl_copy_entry +This function is described in +.Xr acl_copy_entry 3 , +and may be used to copy the contents of an ACL entry. +.It Fn acl_create_entry +This function is described in +.Xr acl_create_entry 3 , +and may be used to create an empty entry in an ACL. +.It Xo +.Fn acl_delete_def_file , +.Fn acl_delete_def_link_np , +.Fn acl_delete_fd_np , +.Fn acl_delete_file_np , +.Fn acl_delete_link_np +.Xc +These functions are described in +.Xr acl_delete 3 , +and may be used to delete ACLs from file system objects. +.It Fn acl_delete_entry +This function is described in +.Xr acl_delete_entry 3 , +and may be used to delete an entry from an ACL. +.It Fn acl_delete_perm +This function is described in +.Xr acl_delete_perm 3 , +and may be used to delete permissions from a permset. +.It Fn acl_dup +This function is described in +.Xr acl_dup 3 , +and may be used to duplicate an ACL structure. +.It Fn acl_free +This function is described in +.Xr acl_free 3 , +and may be used to free userland working ACL storage. +.It Fn acl_from_text +This function is described in +.Xr acl_from_text 3 , +and may be used to convert a text-form ACL into working ACL state, if +the ACL has POSIX.1e semantics. +.It Fn acl_get_entry +This function is described in +.Xr acl_get_entry 3 , +and may be used to retrieve a designated ACL entry from an ACL. +.It Xo +.Fn acl_get_fd , +.Fn acl_get_fd_np , +.Fn acl_get_file , +.Fn acl_get_link_np +.Xc +These functions are described in +.Xr acl_get 3 , +and may be used to retrieve ACLs from file system objects. +.It Fn acl_get_permset +This function is described in +.Xr acl_get_permset 3 , +and may be used to retrieve a permset from an ACL entry. +.It Fn acl_get_qualifier +This function is described in +.Xr acl_get_qualifier 3 , +and may be used to retrieve the qualifier from an ACL entry. +.It Fn acl_get_tag_type +This function is described in +.Xr acl_get_tag_type 3 , +and may be used to retrieve the tag type from an ACL entry. +.It Fn acl_init +This function is described in +.Xr acl_init 3 , +and may be used to allocate a fresh (empty) ACL structure. +.It Xo +.Fn acl_set_fd , +.Fn acl_set_fd_np , +.Fn acl_set_file , +.Fn acl_set_link_np +.Xc +These functions are described in +.Xr acl_set 3 , +and may be used to assign an ACL to a file system object. +.It Fn acl_set_permset +This function is described in +.Xr acl_set_permset 3 , +and may be used to set the permissions of an ACL entry from a permset. +.It Fn acl_set_qualifier +This function is described in +.Xr acl_set_qualifier 3 , +and may be used to set the qualifier of an ACL. +.It Fn acl_set_tag_type +This function is described in +.Xr acl_set_tag_type 3 , +and may be used to set the tag type of an ACL. +.It Fn acl_to_text +This function is described in +.Xr acl_to_text 3 , +and may be used to generate a text-form of a POSIX.1e semantics ACL. +.It Xo +.Fn acl_valid , +.Fn acl_valid_fd_np , +.Fn acl_valid_file_np , +.Fn acl_valid_link_np +.Xc +These functions are described in +.Xr acl_valid 3 , +and may be used to validate an ACL as correct POSIX.1e-semantics, or +as appropriate for a particular file system object regardless of semantics. +.El +.Pp +Documentation of the internal kernel interfaces backing these calls may +be found in +.Xr acl 9 . +The syscalls between the internal interfaces and the public library +routines may change over time, and as such are not documented. +They are not intended to be called directly without going through the +library. +.Sh SEE ALSO +.Xr getfacl 1 , +.Xr setfacl 1 , +.Xr acl_add_perm 3 , +.Xr acl_calc_mask 3 , +.Xr acl_clear_perms 3 , +.Xr acl_copy_entry 3 , +.Xr acl_create_entry 3 , +.Xr acl_delete_entry 3 , +.Xr acl_delete_perm 3 , +.Xr acl_dup 3 , +.Xr acl_free 3 , +.Xr acl_from_text 3 , +.Xr acl_get 3 , +.Xr acl_get_permset 3 , +.Xr acl_get_qualifier 3 , +.Xr acl_get_tag_type 3 , +.Xr acl_init 3 , +.Xr acl_set 3 , +.Xr acl_set_permset 3 , +.Xr acl_set_qualifier 3 , +.Xr acl_set_tag_type 3 , +.Xr acl_to_text 3 , +.Xr acl_valid 3 , +.Xr posix1e 3 , +.Xr acl 9 +.Sh STANDARDS +POSIX.1e assigns security labels to all objects, extending the security +functionality described in POSIX.1. +These additional labels provide fine-grained discretionary access control, +fine-grained capabilities, and labels necessary for mandatory access +control. +POSIX.2c describes a set of userland utilities for manipulating these +labels. +.Pp +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft continues on the cross-platform POSIX.1e +implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 ; +.Fx 5.0 +was the first version to include a complete ACL implementation based +on extended attributes for the UFS and UFS2 file systems. +.Pp +The +.Xr getfacl 1 +and +.Xr setfacl 1 +utilities describe the user tools that permit direct manipulation of complete +file ACLs. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_add_perm.3 b/lib/libc/posix1e/acl_add_perm.3 new file mode 100644 index 0000000..61fe233 --- /dev/null +++ b/lib/libc/posix1e/acl_add_perm.3 @@ -0,0 +1,87 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_add_perm.3,v 1.6 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_ADD_PERM 3 +.Os +.Sh NAME +.Nm acl_add_perm +.Nd add permissions to a permission set +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_add_perm "acl_permset_t permset_d" "acl_perm_t perm" +.Sh DESCRIPTION +The +.Fn acl_add_perm +function +is a POSIX.1e call that adds the permission contained in +.Fa perm +to the permission set +.Fa permset_d . +.Pp +Note: it is not considered an error to attempt to add permissions +that already exist in the permission set. +.Sh RETURN VALUES +.Rv -std acl_add_perm +.Sh ERRORS +The +.Fn acl_add_perm +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa permset_d +is not a valid descriptor for a permission set within an ACL entry. +Argument +.Fa perm +does not contain a valid +.Vt acl_perm_t +value. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_clear_perms 3 , +.Xr acl_delete_perm 3 , +.Xr acl_get_permset 3 , +.Xr acl_set_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_add_perm +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_add_perm +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_calc_mask.3 b/lib/libc/posix1e/acl_calc_mask.3 new file mode 100644 index 0000000..87dc5a7 --- /dev/null +++ b/lib/libc/posix1e/acl_calc_mask.3 @@ -0,0 +1,96 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_calc_mask.3,v 1.5 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_CALC_MASK 3 +.Os +.Sh NAME +.Nm acl_calc_mask +.Nd calculate and set ACL mask permissions +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_calc_mask "acl_t *acl_p" +.Sh DESCRIPTION +The +.Fn acl_calc_mask +function +is a POSIX.1e call that calculates and set the permissions +associated with the +.Dv ACL_MASK +ACL entry of the ACL referred to by +.Fa acl_p . +.Pp +The value of new permissions are the union of the permissions +granted by the +.Dv ACL_GROUP , ACL_GROUP_OBJ , ACL_USER +tag types which +match processes in the file group class contained in the ACL +referred to by +.Fa acl_p . +.Pp +If the ACL referred to by +.Fa acl_p +already contains an +.Dv ACL_MASK +entry, its permissions shall be +overwritten; if it does not contain an +.Dv ACL_MASK +entry, one shall +be added. +.Sh RETURN VALUES +.Rv -std acl_calc_mask +.Sh ERRORS +The +.Fn acl_calc_mask +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa acl_p +does not point to a pointer to a valid ACL. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get_entry 3 , +.Xr acl_valid 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_calc_mask +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_calc_mask +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_calc_mask.c b/lib/libc/posix1e/acl_calc_mask.c new file mode 100644 index 0000000..98280aa --- /dev/null +++ b/lib/libc/posix1e/acl_calc_mask.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: acl_calc_mask.c,v 1.8 2002/03/22 21:52:38 obrien Exp $ + */ + +#include +#include + +#include +#include + +/* + * acl_calc_mask() (23.4.2): calculate and set the permissions + * associated with the ACL_MASK ACL entry. If the ACL already + * contains an ACL_MASK entry, its permissions shall be + * overwritten; if not, one shall be added. + */ +int +acl_calc_mask(acl_t *acl_p) +{ + struct acl *acl_int, *acl_int_new; + acl_t acl_new; + int i, mask_mode, mask_num; + + /* + * (23.4.2.4) requires acl_p to point to a pointer to a valid ACL. + * Since one of the primary reasons to use this function would be + * to calculate the appropriate mask to obtain a valid ACL, we only + * perform sanity checks here and validate the ACL prior to + * returning. + */ + if (acl_p == NULL || *acl_p == NULL) { + errno = EINVAL; + return (-1); + } + acl_int = &(*acl_p)->ats_acl; + if ((acl_int->acl_cnt < 3) || (acl_int->acl_cnt > ACL_MAX_ENTRIES)) { + errno = EINVAL; + return (-1); + } + + acl_new = acl_dup(*acl_p); + if (acl_new == NULL) + return (-1); + acl_int_new = &acl_new->ats_acl; + + mask_mode = 0; + mask_num = -1; + + /* gather permissions and find a mask entry */ + for (i = 0; i < acl_int_new->acl_cnt; i++) { + switch(acl_int_new->acl_entry[i].ae_tag) { + case ACL_USER: + case ACL_GROUP: + case ACL_GROUP_OBJ: + mask_mode |= + acl_int_new->acl_entry[i].ae_perm & ACL_PERM_BITS; + break; + case ACL_MASK: + mask_num = i; + break; + } + } + + /* if a mask entry already exists, overwrite the perms */ + if (mask_num != -1) + acl_int_new->acl_entry[mask_num].ae_perm = mask_mode; + else { + /* if no mask exists, check acl_cnt... */ + if (acl_int_new->acl_cnt == ACL_MAX_ENTRIES) { + errno = ENOMEM; + return (-1); + } + /* ...and add the mask entry */ + acl_int_new->acl_entry[acl_int_new->acl_cnt].ae_tag = ACL_MASK; + acl_int_new->acl_entry[acl_int_new->acl_cnt].ae_id = + ACL_UNDEFINED_ID; + acl_int_new->acl_entry[acl_int_new->acl_cnt].ae_perm = + mask_mode; + acl_int_new->acl_cnt++; + } + + if (acl_valid(acl_new) == -1) { + errno = EINVAL; + acl_free(acl_new); + return (-1); + } + + **acl_p = *acl_new; + acl_free(acl_new); + + return (0); +} diff --git a/lib/libc/posix1e/acl_clear_perms.3 b/lib/libc/posix1e/acl_clear_perms.3 new file mode 100644 index 0000000..2eeb38f --- /dev/null +++ b/lib/libc/posix1e/acl_clear_perms.3 @@ -0,0 +1,77 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_clear_perms.3,v 1.5 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_CLEAR_PERMS 3 +.Os +.Sh NAME +.Nm acl_clear_perms +.Nd clear permissions from a permission set +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_clear_perms "acl_permset_t permset_d" +.Sh DESCRIPTION +The +.Fn acl_clear_perms +function +is a POSIX.1e call that clears all permissions from permissions set +.Fa permset_d . +.Sh RETURN VALUES +.Rv -std acl_clear_perms +.Sh ERRORS +The +.Fn acl_clear_perms +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa permset_d +is not a valid descriptor for a permission set. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_add_perm 3 , +.Xr acl_delete_perm 3 , +.Xr acl_get_permset 3 , +.Xr acl_set_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_clear_perms +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_clear_perms +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_copy.c b/lib/libc/posix1e/acl_copy.c new file mode 100644 index 0000000..864d23e --- /dev/null +++ b/lib/libc/posix1e/acl_copy.c @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: acl_copy.c,v 1.5 2002/03/22 21:52:38 obrien Exp $ + */ + +#include +#include + +#include +#include + +/* + * acl_copy_entry() (23.4.4): copy the contents of ACL entry src_d to + * ACL entry dest_d + */ +int +acl_copy_entry(acl_entry_t dest_d, acl_entry_t src_d) +{ + + if (src_d == NULL || dest_d == NULL || src_d == dest_d) { + errno = EINVAL; + return (-1); + } + + dest_d->ae_tag = src_d->ae_tag; + dest_d->ae_id = src_d->ae_id; + dest_d->ae_perm = src_d->ae_perm; + + return (0); +} + +ssize_t +acl_copy_ext(void *buf_p, acl_t acl, ssize_t size) +{ + + errno = ENOSYS; + return (-1); +} + +acl_t +acl_copy_int(const void *buf_p) +{ + + errno = ENOSYS; + return (NULL); +} diff --git a/lib/libc/posix1e/acl_copy_entry.3 b/lib/libc/posix1e/acl_copy_entry.3 new file mode 100644 index 0000000..8f33488 --- /dev/null +++ b/lib/libc/posix1e/acl_copy_entry.3 @@ -0,0 +1,83 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_copy_entry.3,v 1.5 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_COPY_ENTRY 3 +.Os +.Sh NAME +.Nm acl_copy_entry +.Nd copy an ACL entry to another ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_copy_entry "acl_entry_t dest_d" "acl_entry_t src_d" +.Sh DESCRIPTION +The +.Fn acl_copy_entry +function +is a POSIX.1e call that copies the contents of ACL entry +.Fa src_d +to ACL entry +.Fa dest_d . +.Sh RETURN VALUES +.Rv -std acl_copy_entry +.Sh ERRORS +The +.Fn acl_copy_entry +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa src_d +or +.Fa dest_d +is not a valid descriptor for an ACL entry, or +arguments +.Fa src_d +and +.Fa dest_d +reference the same ACL entry. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get_entry 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_copy_entry +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_copy_entry +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_create_entry.3 b/lib/libc/posix1e/acl_create_entry.3 new file mode 100644 index 0000000..7b829c4 --- /dev/null +++ b/lib/libc/posix1e/acl_create_entry.3 @@ -0,0 +1,80 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_create_entry.3,v 1.5 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 16, 2001 +.Dt ACL_CREATE_ENTRY 3 +.Os +.Sh NAME +.Nm acl_create_entry +.Nd create a new ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_create_entry "acl_t *acl_p" "acl_entry_t *entry_p" +.Sh DESCRIPTION +The +.Fn acl_create_entry +function +is a POSIX.1e call that creates a new ACL entry in the ACL +pointed to by +.Fa acl_p . +.Sh RETURN VALUES +.Rv -std acl_create_entry +.Sh ERRORS +The +.Fn acl_create_entry +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa acl_p +does not point to a pointer to a valid ACL. +.It Bq Er ENOMEM +The ACL working storage requires more memory than is +allowed by the hardware or system-imposed memory +management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_delete_entry 3 , +.Xr acl_get_entry 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_create_entry +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_create_entry +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_delete.3 b/lib/libc/posix1e/acl_delete.3 new file mode 100644 index 0000000..86f8a7b --- /dev/null +++ b/lib/libc/posix1e/acl_delete.3 @@ -0,0 +1,138 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_delete.3,v 1.18 2004/07/05 17:12:52 ru Exp $ +.\" +.Dd December 29, 2002 +.Dt ACL_DELETE 3 +.Os +.Sh NAME +.Nm acl_delete_def_file , +.Nm acl_delete_def_link_np , +.Nm acl_delete_fd_np , +.Nm acl_delete_file_np , +.Nm acl_delete_link_np +.Nd delete an ACL from a file +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_delete_def_file "const char *path_p" +.Ft int +.Fn acl_delete_def_link_np "const char *path_p" +.Ft int +.Fn acl_delete_fd_np "int filedes" "acl_type_t type" +.Ft int +.Fn acl_delete_file_np "const char *path_p" "acl_type_t type" +.Ft int +.Fn acl_delete_link_np "const char *path_p" "acl_type_t type" +.Sh DESCRIPTION +The +.Fn acl_delete_def_file , +.Fn acl_delete_def_link_np , +.Fn acl_delete_fd_np , +.Fn acl_delete_file_np , +and +.Fn acl_delete_link_np +each allow the deletion of an ACL from a file. +The +.Fn acl_delete_def_file +function +is a POSIX.1e call that deletes the default ACL from a file (normally a +directory) by name; the remainder of the calls are non-portable extensions +that permit the deletion of arbitrary ACL types from a file/directory +either by path name or file descriptor. +The +.Fn _file +variations follow a symlink if it occurs in the last segment of the +path name; the +.Fn _link +variations operate on the symlink itself. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +.Rv -std acl_delete +.Sh ERRORS +If any of the following conditions occur, these functions shall return -1 +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EACCES +Search permission is denied for a component of the path prefix, or the +object exists and the process does not have appropriate access rights. +.It Bq Er EBADF +The +.Va fd +argument is not a valid file descriptor. +.It Bq Er EINVAL +The ACL type passed is invalid for this file object. +.It Bq Er ENAMETOOLONG +A component of a pathname exceeded 255 characters, or an +entire path name exceeded 1023 characters. +.It Bq Er ENOENT +The named object does not exist, or the +.Va path_p +argument points to an empty string. +.It Bq Er ENOMEM +Insufficient memory available to fulfill request. +.It Bq Er ENOTDIR +A component of the path prefix is not a directory. +.Pp +Argument +.Va path_p +must be a directory, and is not. +.It Bq Er EOPNOTSUPP +The file system does not support ACL deletion. +.It Bq Er EPERM +The process does not have appropriate privilege to perform the operation +to delete an ACL. +.It Bq Er EROFS +The file system is read-only. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get 3 , +.Xr acl_set 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_delete.c b/lib/libc/posix1e/acl_delete.c new file mode 100644 index 0000000..13fd8b8 --- /dev/null +++ b/lib/libc/posix1e/acl_delete.c @@ -0,0 +1,73 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_delete.c,v 1.8 2002/12/29 20:47:05 rwatson Exp $ + */ + +/* + * acl_delete_def_file -- remove a default acl from a file + */ + +#include +#include +#include + +int +acl_delete_def_file(const char *path_p) +{ + + return (__acl_delete_file(path_p, ACL_TYPE_DEFAULT)); +} + +int +acl_delete_def_link_np(const char *path_p) +{ + + return (__acl_delete_link(path_p, ACL_TYPE_DEFAULT)); +} + +int +acl_delete_file_np(const char *path_p, acl_type_t type) +{ + + return (__acl_delete_file(path_p, type)); +} + +int +acl_delete_link_np(const char *path_p, acl_type_t type) +{ + + return (__acl_delete_link(path_p, type)); +} + + +int +acl_delete_fd_np(int filedes, acl_type_t type) +{ + + return (__acl_delete_fd(filedes, type)); +} diff --git a/lib/libc/posix1e/acl_delete_entry.3 b/lib/libc/posix1e/acl_delete_entry.3 new file mode 100644 index 0000000..1ab3fb2 --- /dev/null +++ b/lib/libc/posix1e/acl_delete_entry.3 @@ -0,0 +1,81 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_delete_entry.3,v 1.6 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_DELETE_ENTRY 3 +.Os +.Sh NAME +.Nm acl_delete_entry +.Nd delete an ACL entry from an ACL +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_delete_entry "acl_t acl" "acl_entry_t entry_d" +.Sh DESCRIPTION +The +.Fn acl_delete_entry +function +is a POSIX.1e call that removes the ACL entry +.Fa entry_d +from ACL +.Fa acl . +.Sh RETURN VALUES +.Rv -std acl_delete_entry +.Sh ERRORS +The +.Fn acl_delete_entry +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa acl +does not point to a valid ACL. +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry in +.Fa acl . +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_copy_entry 3 , +.Xr acl_get_entry 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_delete_entry +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_delete_entry +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_delete_entry.c b/lib/libc/posix1e/acl_delete_entry.c new file mode 100644 index 0000000..98bd971 --- /dev/null +++ b/lib/libc/posix1e/acl_delete_entry.c @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_delete_entry.c,v 1.7 2004/01/06 20:29:40 nectar Exp $ + */ + +#include +#include +#include +#include + +/* + * acl_delete_entry() (23.4.9): remove the ACL entry indicated by entry_d + * from acl. + */ +int +acl_delete_entry(acl_t acl, acl_entry_t entry_d) +{ + struct acl *acl_int; + int i; + + if (acl == NULL || entry_d == NULL) { + errno = EINVAL; + return (-1); + } + + acl_int = &acl->ats_acl; + + if ((acl->ats_acl.acl_cnt < 1) || + (acl->ats_acl.acl_cnt > ACL_MAX_ENTRIES)) { + errno = EINVAL; + return (-1); + } + for (i = 0; i < acl->ats_acl.acl_cnt; i++) { + /* if this is our entry... */ + if ((acl->ats_acl.acl_entry[i].ae_tag == entry_d->ae_tag) && + (acl->ats_acl.acl_entry[i].ae_id == entry_d->ae_id)) { + /* ...shift the remaining entries... */ + for (; i < acl->ats_acl.acl_cnt - 1; ++i) + acl->ats_acl.acl_entry[i] = + acl->ats_acl.acl_entry[i+1]; + /* ...drop the count and zero the unused entry... */ + acl->ats_acl.acl_cnt--; + bzero(&acl->ats_acl.acl_entry[i], + sizeof(struct acl_entry)); + acl->ats_cur_entry = 0; + return (0); + } + } + + + errno = EINVAL; + return (-1); +} diff --git a/lib/libc/posix1e/acl_delete_perm.3 b/lib/libc/posix1e/acl_delete_perm.3 new file mode 100644 index 0000000..dd61123 --- /dev/null +++ b/lib/libc/posix1e/acl_delete_perm.3 @@ -0,0 +1,82 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_delete_perm.3,v 1.6 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_DELETE_PERM 3 +.Os +.Sh NAME +.Nm acl_delete_perm +.Nd delete permissions from a permission set +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_delete_perm "acl_permset_t permset_d" "acl_perm_t perm" +.Sh DESCRIPTION +The +.Fn acl_delete_perm +function +is a POSIX.1e call that removes specific permissions from permissions set +.Fa perm . +.Sh RETURN VALUES +.Rv -std acl_delete_perm +.Sh ERRORS +The +.Fn acl_delete_perm +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa permset_d +is not a valid descriptor for a permission set. +Argument +.Fa perm +does not contain a valid +.Vt acl_perm_t +value. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_add_perm 3 , +.Xr acl_clear_perms 3 , +.Xr acl_get_permset 3 , +.Xr acl_set_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_delete_perm +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_delete_perm +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_dup.3 b/lib/libc/posix1e/acl_dup.3 new file mode 100644 index 0000000..f21edcc --- /dev/null +++ b/lib/libc/posix1e/acl_dup.3 @@ -0,0 +1,108 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_dup.3,v 1.13 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd January 28, 2000 +.Dt ACL_DUP 3 +.Os +.Sh NAME +.Nm acl_dup +.Nd duplicate an ACL +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft acl_t +.Fn acl_dup "acl_t acl" +.Sh DESCRIPTION +The +.Fn acl_dup +function returns a pointer to a copy of the ACL pointed to by the argument +.Va acl . +.Pp +This function may cause memory to be allocated. +The caller should free any +releasable memory, when the new ACL is no longer required, by calling +.Xr acl_free 3 +with the +.Va (void*)acl_t +as an argument. +.Pp +Any existing ACL pointers that refer to the ACL referred to by +.Va acl +shall continue to refer to the ACL. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +Upon successful completion, this function shall return a pointer to the +duplicate ACL. +Otherwise, a value of +.Va (acl_t)NULL +shall be returned, and +.Va errno +shall be set to indicate the error. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_init +function shall return a value of +.Va (acl_t)NULL +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Va acl +does not point to a valid ACL. +.It Bq Er ENOMEM +The +.Va acl_t +to be returned requires more memory than is allowed by the hardware or +system-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_free 3 , +.Xr acl_get 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_entry.c b/lib/libc/posix1e/acl_entry.c new file mode 100644 index 0000000..c73fa63 --- /dev/null +++ b/lib/libc/posix1e/acl_entry.c @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_entry.c,v 1.7 2002/03/22 21:52:38 obrien Exp $ + */ + +#include +#include + +#include +#include + +/* + * acl_create_entry() (23.4.7): create a new ACL entry in the ACL pointed + * to by acl_p. + */ +int +acl_create_entry(acl_t *acl_p, acl_entry_t *entry_p) +{ + struct acl *acl_int; + + if (acl_p == NULL) { + errno = EINVAL; + return (-1); + } + + acl_int = &(*acl_p)->ats_acl; + + if ((acl_int->acl_cnt >= ACL_MAX_ENTRIES) || (acl_int->acl_cnt < 0)) { + errno = EINVAL; + return (-1); + } + + *entry_p = &acl_int->acl_entry[acl_int->acl_cnt++]; + + (**entry_p).ae_tag = ACL_UNDEFINED_TAG; + (**entry_p).ae_id = ACL_UNDEFINED_ID; + (**entry_p).ae_perm = ACL_PERM_NONE; + + (*acl_p)->ats_cur_entry = 0; + + return (0); +} + +/* + * acl_get_entry() (23.4.14): returns an ACL entry from an ACL + * indicated by entry_id. + */ +int +acl_get_entry(acl_t acl, int entry_id, acl_entry_t *entry_p) +{ + struct acl *acl_int; + + if (acl == NULL) { + errno = EINVAL; + return (-1); + } + acl_int = &acl->ats_acl; + + switch(entry_id) { + case ACL_FIRST_ENTRY: + acl->ats_cur_entry = 0; + /* PASSTHROUGH */ + case ACL_NEXT_ENTRY: + if (acl->ats_cur_entry >= acl->ats_acl.acl_cnt) + return 0; + *entry_p = &acl_int->acl_entry[acl->ats_cur_entry++]; + return (1); + } + + errno = EINVAL; + return (-1); +} diff --git a/lib/libc/posix1e/acl_free.3 b/lib/libc/posix1e/acl_free.3 new file mode 100644 index 0000000..514ab53 --- /dev/null +++ b/lib/libc/posix1e/acl_free.3 @@ -0,0 +1,87 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_free.3,v 1.13 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd January 28, 2000 +.Dt ACL_FREE 3 +.Os +.Sh NAME +.Nm acl_free +.Nd free ACL working state +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_free "void *obj_p" +.Sh DESCRIPTION +The +.Fn acl_free +call allows the freeing of ACL working space, such as is allocated by +.Xr acl_dup 3 , +or +.Xr acl_from_text 3 . +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +.Rv -std acl_free +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_free +function shall return -1 and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +The value of the +.Va obj_p +argument is invalid. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_dup 3 , +.Xr acl_from_text 3 , +.Xr acl_get 3 , +.Xr acl_init 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_free.c b/lib/libc/posix1e/acl_free.c new file mode 100644 index 0000000..37d877d --- /dev/null +++ b/lib/libc/posix1e/acl_free.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 1999, 2000, 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_free.c,v 1.5 2002/03/22 21:52:38 obrien Exp $ + */ + +/* + * acl_free -- free ACL objects from user memory + */ + +#include +#include +#include +#include + +/* + * acl_free() (23.4.12): free any releasable memory allocated to the + * ACL data object identified by obj_p. + */ +int +acl_free(void *obj_p) +{ + + if (obj_p) { + free(obj_p); + obj_p = NULL; + } + + return (0); +} diff --git a/lib/libc/posix1e/acl_from_text.3 b/lib/libc/posix1e/acl_from_text.3 new file mode 100644 index 0000000..b510000 --- /dev/null +++ b/lib/libc/posix1e/acl_from_text.3 @@ -0,0 +1,128 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_from_text.3,v 1.16 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd January 28, 2000 +.Dt ACL_FROM_TEXT 3 +.Os +.Sh NAME +.Nm acl_from_text +.Nd create an ACL from text +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft acl_t +.Fn acl_from_text "const char *buf_p" +.Sh DESCRIPTION +The +.Fn acl_from_text +function converts the text form of an ACL referred to by +.Va buf_p +into the internal working structure for ACLs, appropriate for applying to +files or manipulating. +.Pp +This function may cause memory to be allocated. +The caller should free any +releasable memory, when the new ACL is no longer required, by calling +.Xr acl_free 3 +with the +.Va (void *)acl_t +as an argument. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +Upon successful completion, the function shall return a pointer to the +internal representation of the ACL in working storage. +Otherwise, a value +of +.Va (acl_t)NULL +shall be returned, and +.Va errno +shall be set to indicate the error. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_from_text +function shall return a value of +.Va (acl_t)NULL +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Va buf_p +cannot be translated into an ACL. +.It Bq Er ENOMEM +The ACL working storage requires more memory than is allowed by the +hardware or system-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_free 3 , +.Xr acl_get 3 , +.Xr acl_to_text 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson +.Sh BUGS +The +.Fn acl_from_text +and +.Fn acl_to_text +functions +rely on the +.Xr getpwent 3 +library calls to manage username and uid mapping, as well as the +.Xr getgrent 3 +library calls to manage groupname and gid mapping. +These calls are not +thread safe, and so transitively, neither are +.Fn acl_from_text +and +.Fn acl_to_text . +These functions may also interfere with stateful +calls associated with the +.Fn getpwent +and +.Fn getgrent +calls. diff --git a/lib/libc/posix1e/acl_from_text.c b/lib/libc/posix1e/acl_from_text.c new file mode 100644 index 0000000..0d9ded9 --- /dev/null +++ b/lib/libc/posix1e/acl_from_text.c @@ -0,0 +1,287 @@ +/* + * Copyright (c) 1999, 2000, 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_from_text.c,v 1.11 2007/02/26 02:07:02 kientzle Exp $ + */ + +/* + * acl_from_text: Convert a text-form ACL from a string to an acl_t. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "acl_support.h" + +static int _posix1e_acl_name_to_id(acl_tag_t tag, char *name, uid_t *id); +static acl_tag_t acl_string_to_tag(char *tag, char *qualifier); +static char *string_skip_whitespace(char *string); +static void string_trim_trailing_whitespace(char *string); + +static char * +string_skip_whitespace(char *string) +{ + + while (*string && ((*string == ' ') || (*string == '\t'))) { + string++; + } + return (string); +} + +static void +string_trim_trailing_whitespace(char *string) +{ + char *end; + + if (*string == '\0') + return; + + end = string + strlen(string) - 1; + + while (end != string) { + if ((*end == ' ') || (*end == '\t')) { + *end = '\0'; + end--; + } else { + return; + } + } + + return; +} + +static acl_tag_t +acl_string_to_tag(char *tag, char *qualifier) +{ + + if (*qualifier == '\0') { + if ((!strcmp(tag, "user")) || (!strcmp(tag, "u"))) { + return (ACL_USER_OBJ); + } else + if ((!strcmp(tag, "group")) || (!strcmp(tag, "g"))) { + return (ACL_GROUP_OBJ); + } else + if ((!strcmp(tag, "mask")) || (!strcmp(tag, "m"))) { + return (ACL_MASK); + } else + if ((!strcmp(tag, "other")) || (!strcmp(tag, "o"))) { + return (ACL_OTHER); + } else + return(-1); + } else { + if ((!strcmp(tag, "user")) || (!strcmp(tag, "u"))) { + return(ACL_USER); + } else + if ((!strcmp(tag, "group")) || (!strcmp(tag, "g"))) { + return(ACL_GROUP); + } else + return(-1); + } +} + +/* + * acl_from_text -- Convert a string into an ACL. + * Postpone most validity checking until the end and call acl_valid() to do + * that. + */ +acl_t +acl_from_text(const char *buf_p) +{ + acl_tag_t t; + acl_perm_t p; + acl_t acl; + char *mybuf_p, *line, *cur, *notcomment, *comment, *entry; + char *tag, *qualifier, *permission; + int error; + uid_t id; + + /* Local copy we can mess up. */ + mybuf_p = strdup(buf_p); + if (mybuf_p == NULL) + return(NULL); + + acl = acl_init(3); + if (acl == NULL) { + free(mybuf_p); + return(NULL); + } + + /* Outer loop: delimit at \n boundaries. */ + cur = mybuf_p; + while ((line = strsep(&cur, "\n"))) { + /* Now split the line on the first # to strip out comments. */ + comment = line; + notcomment = strsep(&comment, "#"); + + /* Inner loop: delimit at ',' boundaries. */ + while ((entry = strsep(¬comment, ","))) { + /* Now split into three ':' delimited fields. */ + tag = strsep(&entry, ":"); + if (tag == NULL) { + errno = EINVAL; + goto error_label; + } + tag = string_skip_whitespace(tag); + if ((*tag == '\0') && (!entry)) { + /* + * Is an entirely comment line, skip to next + * comma. + */ + continue; + } + string_trim_trailing_whitespace(tag); + + qualifier = strsep(&entry, ":"); + if (qualifier == NULL) { + errno = EINVAL; + goto error_label; + } + qualifier = string_skip_whitespace(qualifier); + string_trim_trailing_whitespace(qualifier); + + permission = strsep(&entry, ":"); + if (permission == NULL || entry) { + errno = EINVAL; + goto error_label; + } + permission = string_skip_whitespace(permission); + string_trim_trailing_whitespace(permission); + + t = acl_string_to_tag(tag, qualifier); + if (t == -1) { + errno = EINVAL; + goto error_label; + } + + error = _posix1e_acl_string_to_perm(permission, &p); + if (error == -1) { + errno = EINVAL; + goto error_label; + } + + switch(t) { + case ACL_USER_OBJ: + case ACL_GROUP_OBJ: + case ACL_MASK: + case ACL_OTHER: + if (*qualifier != '\0') { + errno = EINVAL; + goto error_label; + } + id = 0; + break; + + case ACL_USER: + case ACL_GROUP: + error = _posix1e_acl_name_to_id(t, qualifier, + &id); + if (error == -1) + goto error_label; + break; + + default: + errno = EINVAL; + goto error_label; + } + + error = _posix1e_acl_add_entry(acl, t, id, p); + if (error == -1) + goto error_label; + } + } + +#if 0 + /* XXX Should we only return ACLs valid according to acl_valid? */ + /* Verify validity of the ACL we read in. */ + if (acl_valid(acl) == -1) { + errno = EINVAL; + goto error_label; + } +#endif + + return(acl); + +error_label: + acl_free(acl); + free(mybuf_p); + return(NULL); +} + +/* + * Given a username/groupname from a text form of an ACL, return the uid/gid + * XXX NOT THREAD SAFE, RELIES ON GETPWNAM, GETGRNAM + * XXX USES *PW* AND *GR* WHICH ARE STATEFUL AND THEREFORE THIS ROUTINE + * MAY HAVE SIDE-EFFECTS + * + * XXX currently doesn't deal correctly with a numeric uid being passed + * instead of a username. What is correct behavior here? Check chown. + */ +static int +_posix1e_acl_name_to_id(acl_tag_t tag, char *name, uid_t *id) +{ + struct group *g; + struct passwd *p; + unsigned long l; + char *endp; + + switch(tag) { + case ACL_USER: + p = getpwnam(name); + if (p == NULL) { + l = strtoul(name, &endp, 0); + if (*endp != '\0' || l != (unsigned long)(uid_t)l) { + errno = EINVAL; + return (-1); + } + *id = (uid_t)l; + return (0); + } + *id = p->pw_uid; + return (0); + + case ACL_GROUP: + g = getgrnam(name); + if (g == NULL) { + l = strtoul(name, &endp, 0); + if (*endp != '\0' || l != (unsigned long)(gid_t)l) { + errno = EINVAL; + return (-1); + } + *id = (gid_t)l; + return (0); + } + *id = g->gr_gid; + return (0); + + default: + return (EINVAL); + } +} diff --git a/lib/libc/posix1e/acl_get.3 b/lib/libc/posix1e/acl_get.3 new file mode 100644 index 0000000..3a167af --- /dev/null +++ b/lib/libc/posix1e/acl_get.3 @@ -0,0 +1,154 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_get.3,v 1.18 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd December 29, 2002 +.Dt ACL_GET 3 +.Os +.Sh NAME +.Nm acl_get_fd , +.Nm acl_get_fd_np , +.Nm acl_get_file , +.Nm acl_get_link_np +.Nd get an ACL for a file +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft acl_t +.Fn acl_get_fd "int fd" +.Ft acl_t +.Fn acl_get_fd_np "int fd" "acl_type_t type" +.Ft acl_t +.Fn acl_get_file "const char *path_p" "acl_type_t type" +.Ft acl_t +.Fn acl_get_link_np "const char *path_p" "acl_type_t type" +.Sh DESCRIPTION +The +.Fn acl_get_fd , +.Fn acl_get_file , +.Fn acl_get_link_np , +and +.Fn acl_get_fd_np +each allow the retrieval of an ACL from a file. +The +.Fn acl_get_fd +is a POSIX.1e call that allows the retrieval of an ACL of type +ACL_TYPE_ACCESS +from a file descriptor. +The +.Fn acl_get_fd_np +function +is a non-portable form of +.Fn acl_get_fd +that allows the retrieval of any type of ACL from a file descriptor. +The +.Fn acl_get_file +function is a POSIX.1e call that allows the retrieval of a +specified type of ACL from a file by name; +.Fn acl_get_link_np +is a non-portable variation on +.Fn acl_get_file +which does not follow a symlink if the target of the call is a +symlink. +.Pp +These functions may cause memory to be allocated. +The caller should free +any releasable memory, when the new ACL is no longer required, by calling +.Xr acl_free 3 +with the +.Va (void *)acl_t +as an argument. +.Pp +The ACL in the working storage is an independent copy of the ACL associated +with the object referred to by +.Va fd . +The ACL in the working storage shall not participate in any access control +decisions. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +Upon successful completion, the function shall return a pointer to the ACL +that was retrieved. +Otherwise, a value of +.Va (acl_t)NULL +shall be returned, and +.Va errno +shall be set to indicate the error. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_get_fd +function shall return a value of +.Va (acl_t)NULL +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EACCES +Search permission is denied for a component of the path prefix, or the +object exists and the process does not have appropriate access rights. +.It Bq Er EBADF +The +.Va fd +argument is not a valid file descriptor. +.It Bq Er EINVAL +The ACL type passed is invalid for this file object. +.It Bq Er ENAMETOOLONG +A component of a pathname exceeded 255 characters, or an +entire path name exceeded 1023 characters. +.It Bq Er ENOENT +The named object does not exist, or the +.Va path_p +argument points to an empty string. +.It Bq Er ENOMEM +Insufficient memory available to fulfill request. +.It Bq Er EOPNOTSUPP +The file system does not support ACL retrieval. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_free 3 , +.Xr acl_get 3 , +.Xr acl_set 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_get.c b/lib/libc/posix1e/acl_get.c new file mode 100644 index 0000000..259db9b --- /dev/null +++ b/lib/libc/posix1e/acl_get.c @@ -0,0 +1,213 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_get.c,v 1.12 2002/12/29 20:47:05 rwatson Exp $" + */ + +/* + * acl_get_fd - syscall wrapper for retrieving access ACL by fd + * acl_get_fd_np - syscall wrapper for retrieving ACL by fd (non-POSIX) + * acl_get_file - syscall wrapper for retrieving ACL by filename + * acl_get_link_np - syscall wrapper for retrieving ACL by filename (NOFOLLOW) + * (non-POSIX) + * acl_get_perm_np() checks if a permission is in the specified + * permset (non-POSIX) + * acl_get_permset() returns the permission set in the ACL entry + * acl_get_qualifier() retrieves the qualifier of the tag from the ACL entry + * acl_get_tag_type() returns the tag type for the ACL entry entry_d + */ + +#include +#include + +#include +#include +#include + +acl_t +acl_get_file(const char *path_p, acl_type_t type) +{ + acl_t aclp; + int error; + + aclp = acl_init(ACL_MAX_ENTRIES); + if (aclp == NULL) + return (NULL); + + error = __acl_get_file(path_p, type, &aclp->ats_acl); + if (error) { + acl_free(aclp); + return (NULL); + } + + return (aclp); +} + +acl_t +acl_get_link_np(const char *path_p, acl_type_t type) +{ + acl_t aclp; + int error; + + aclp = acl_init(ACL_MAX_ENTRIES); + if (aclp == NULL) + return (NULL); + + error = __acl_get_link(path_p, type, &aclp->ats_acl); + if (error) { + acl_free(aclp); + return (NULL); + } + + return (aclp); +} + +acl_t +acl_get_fd(int fd) +{ + acl_t aclp; + int error; + + aclp = acl_init(ACL_MAX_ENTRIES); + if (aclp == NULL) + return (NULL); + + error = __acl_get_fd(fd, ACL_TYPE_ACCESS, &aclp->ats_acl); + if (error) { + acl_free(aclp); + return (NULL); + } + + return (aclp); +} + +acl_t +acl_get_fd_np(int fd, acl_type_t type) +{ + acl_t aclp; + int error; + + aclp = acl_init(ACL_MAX_ENTRIES); + if (aclp == NULL) + return (NULL); + + error = __acl_get_fd(fd, type, &aclp->ats_acl); + if (error) { + acl_free(aclp); + return (NULL); + } + + return (aclp); +} + +int +acl_get_perm_np(acl_permset_t permset_d, acl_perm_t perm) +{ + + if (permset_d == NULL) { + errno = EINVAL; + return (-1); + } + + switch(perm) { + case ACL_READ: + case ACL_WRITE: + case ACL_EXECUTE: + if (*permset_d & perm) + return (1); + break; + default: + errno = EINVAL; + return (-1); + } + + return (0); +} + +/* + * acl_get_permset() (23.4.17): return via permset_p a descriptor to + * the permission set in the ACL entry entry_d. + */ +int +acl_get_permset(acl_entry_t entry_d, acl_permset_t *permset_p) +{ + + if (entry_d == NULL || permset_p == NULL) { + errno = EINVAL; + return (-1); + } + + *permset_p = &entry_d->ae_perm; + + return (0); +} + +/* + * acl_get_qualifier() (23.4.18): retrieve the qualifier of the tag + * for the ACL entry entry_d. + */ +void * +acl_get_qualifier(acl_entry_t entry_d) +{ + uid_t *retval; + + if (entry_d == NULL) { + errno = EINVAL; + return (NULL); + } + + switch(entry_d->ae_tag) { + case ACL_USER: + case ACL_GROUP: + retval = malloc(sizeof(uid_t)); + if (retval == NULL) + return (NULL); + *retval = entry_d->ae_id; + return (retval); + } + + errno = EINVAL; + return (NULL); +} + +/* + * acl_get_tag_type() (23.4.19): return the tag type for the ACL + * entry entry_p. + */ +int +acl_get_tag_type(acl_entry_t entry_d, acl_tag_t *tag_type_p) +{ + + if (entry_d == NULL || tag_type_p == NULL) { + errno = EINVAL; + return (-1); + } + + *tag_type_p = entry_d->ae_tag; + + return (0); +} diff --git a/lib/libc/posix1e/acl_get_entry.3 b/lib/libc/posix1e/acl_get_entry.3 new file mode 100644 index 0000000..16ac7e5 --- /dev/null +++ b/lib/libc/posix1e/acl_get_entry.3 @@ -0,0 +1,143 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_get_entry.3,v 1.9 2005/11/17 12:59:59 ru Exp $ +.\" +.Dd April 13, 2001 +.Dt ACL_GET_ENTRY 3 +.Os +.Sh NAME +.Nm acl_get_entry +.Nd retrieve an ACL entry from an ACL +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_get_entry "acl_t acl" "int entry_id" "acl_entry_t *entry_p" +.Sh DESCRIPTION +The +.Fn acl_get_entry +function +is a POSIX.1e call that retrieves a descriptor for an ACL entry +specified by the argument +.Fa entry_d +within the ACL indicated by the argument +.Fa acl . +.Pp +If the value of +.Fa entry_id +is +.Dv ACL_FIRST_ENTRY , +then the function will return in +.Fa entry_p +a descriptor for the first ACL entry within +.Fa acl . +If a call is made to +.Fn acl_get_entry +with +.Fa entry_id +set to +.Dv ACL_NEXT_ENTRY +when there has not been either an initial successful call to +.Fn acl_get_entry , +or a previous successful call to +.Fn acl_create_entry , +.Fn acl_delete_entry , +.Fn acl_dup , +.Fn acl_from_text , +.Fn acl_get_fd , +.Fn acl_get_file , +.Fn acl_set_fd , +.Fn acl_set_file , +or +.Fn acl_valid , +then the result is unspecified. +.Sh RETURN VALUES +If the +.Fn acl_get_entry +function successfully obtains an ACL entry, a value of 1 is returned. +If the ACL has no ACL entries, the +.Fn acl_get_entry +returns a value of 0. +If the value of +.Fa entry_id +is +.Dv ACL_NEXT_ENTRY +and the last ACL entry in the ACL has already been returned by a +previous call to +.Fn acl_get_entry , +a value of 0 will be returned until a successful call with +.Fa entry_id +of +.Dv ACL_FIRST_ENTRY +is made. +Otherwise, a value of -1 will be returned and +the global variable +.Va errno +will be set to indicate the error. +.Sh ERRORS +The +.Fn acl_get_entry +fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa acl +does not point to a valid ACL. +Argument +.Fa entry_id +is neither +.Dv ACL_FIRST_ENTRY +nor +.Dv ACL_NEXT_ENTRY . +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_calc_mask 3 , +.Xr acl_create_entry 3 , +.Xr acl_delete_entry 3 , +.Xr acl_dup 3 , +.Xr acl_from_text 3 , +.Xr acl_get_fd 3 , +.Xr acl_get_file 3 , +.Xr acl_init 3 , +.Xr acl_set_fd 3 , +.Xr acl_set_file 3 , +.Xr acl_valid 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_entry +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_entry +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_get_perm_np.3 b/lib/libc/posix1e/acl_get_perm_np.3 new file mode 100644 index 0000000..879c8df --- /dev/null +++ b/lib/libc/posix1e/acl_get_perm_np.3 @@ -0,0 +1,92 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_get_perm_np.3,v 1.4 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd April 10, 2001 +.Dt ACL_GET_PERM_NP 3 +.Os +.Sh NAME +.Nm acl_get_perm_np +.Nd "check if a permission is set in a permission set" +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_get_perm_np "acl_permset_t permset_d" "acl_perm_t perm" +.Sh DESCRIPTION +The +.Fn acl_get_perm_np +function +is a non-portable function that checks if a permission is set in +a permission set. +.Sh RETURN VALUES +If the permission in +.Fa perm +is set in the permission set +.Fa permset_d , +a value of +1 +is returned, otherwise a value of +0 +is returned. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_get_perm_np +function will return a value of +\-1 +and set global variable +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa perm +does not contain a valid ACL permission or argument +.Fa permset_d +is not a valid ACL permset. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_add_perm 3 , +.Xr acl_clear_perms 3 , +.Xr acl_delete_perm 3 , +.Xr acl_get_permset 3 , +.Xr acl_set_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_perm_np +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_perm_np +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_get_permset.3 b/lib/libc/posix1e/acl_get_permset.3 new file mode 100644 index 0000000..de0f92c --- /dev/null +++ b/lib/libc/posix1e/acl_get_permset.3 @@ -0,0 +1,81 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_get_permset.3,v 1.5 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_GET_PERMSET 3 +.Os +.Sh NAME +.Nm acl_get_permset +.Nd retrieve permission set from an ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_get_permset "acl_entry_t entry_d" "acl_permset_t *permset_p" +.Sh DESCRIPTION +The +.Fn acl_get_permset +function +is a POSIX.1e call that returns via +.Fa permset_p +a descriptor to the permission set in the ACL entry +.Fa entry_d . +Subsequent operations using the returned permission set operate +on the permission set within the ACL entry. +.Sh RETURN VALUES +.Rv -std acl_get_permset +.Sh ERRORS +The +.Fn acl_get_permset +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_add_perm 3 , +.Xr acl_clear_perms 3 , +.Xr acl_delete_perm 3 , +.Xr acl_set_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_permset +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_permset +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_get_qualifier.3 b/lib/libc/posix1e/acl_get_qualifier.3 new file mode 100644 index 0000000..dbc32e1 --- /dev/null +++ b/lib/libc/posix1e/acl_get_qualifier.3 @@ -0,0 +1,138 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_get_qualifier.3,v 1.7 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd March 13, 2001 +.Dt ACL_GET_QUALIFIER 3 +.Os +.Sh NAME +.Nm acl_get_qualifier +.Nd retrieve the qualifier from an ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft void * +.Fn acl_get_qualifier "acl_entry_t entry_d" +.Sh DESCRIPTION +The +.Fn acl_get_qualifier +function +is a POSIX.1e call that retrieves the qualifier of the tag for +the ACL entry indicated by the argument +.Fa entry_d +into working storage and returns a pointer to that storage. +.Pp +If the value of the tag type in the ACL entry referred to by +.Fa entry_d +is +.Dv ACL_USER , +then the value returned by +.Fn acl_get_qualifier +will be a pointer to type +.Vt uid_t . +.Pp +If the value of the tag type in +the ACL entry referred to by +.Fa entry_d +is +.Dv ACL_GROUP , +then the value returned by +.Fn acl_get_qualifier +will be a pointer to type +.Vt gid_t . +.Pp +If the value of the tag type in the ACL entry referred to by +.Fa entry_d +is +.Dv ACL_UNDEFINED_TAG , ACL_USER_OBJ , ACL_GROUP_OBJ , +.Dv ACL_OTHER , ACL_MASK , +or an implementation-defined value for which a qualifier +is not supported, then +.Fn acl_get_qualifier +will return a value of +.Vt ( void * ) Ns Dv NULL +and the function will fail. +.Pp +This function may cause memory to be allocated. +The caller should +free any releasable memory, when the new qualifier is no longer +required, by calling +.Fn acl_free +with +.Vt void * +as the argument. +.Sh RETURN VALUES +The +.Fn acl_get_qualifier +function returns a pointer to the allocated storage if successful; +otherwise a +.Dv NULL +pointer is returned and the global variable +.Va errno +is set to indicate the error. +.Sh ERRORS +The +.Fn acl_get_qualifier +fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +does not point to a valid descriptor for an ACL entry. +The +value of the tag type in the ACL entry referenced by argument +.Fa entry_d +is not +.Dv ACL_USER +or +.Dv ACL_GROUP . +.It Bq Er ENOMEM +The value to be returned requires more memory than is allowed +by the hardware or system-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_create_entry 3 , +.Xr acl_free 3 , +.Xr acl_get_entry 3 , +.Xr acl_get_tag_type 3 , +.Xr acl_set_qualifier 3 , +.Xr acl_set_tag_type 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_qualifier +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_qualifier +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_get_tag_type.3 b/lib/libc/posix1e/acl_get_tag_type.3 new file mode 100644 index 0000000..9b3fb47 --- /dev/null +++ b/lib/libc/posix1e/acl_get_tag_type.3 @@ -0,0 +1,83 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_get_tag_type.3,v 1.7 2002/12/27 12:15:28 schweikh Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_GET_TAG_TYPE 3 +.Os +.Sh NAME +.Nm acl_get_tag_type +.Nd retrieve the tag type from an ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_get_tag_type "acl_entry_t entry_d" "acl_tag_t *tag_type_p" +.Sh DESCRIPTION +The +.Fn acl_get_tag_type +function +is a POSIX.1e call that returns the tag type for the ACL entry +.Fa entry_d . +Upon successful completion, the location referred to by the argument +.Fa tag_type_p +will be set to the tag type of the ACL entry +.Fa entry_d . +.Sh RETURN VALUES +.Rv -std acl_get_tag_type +.Sh ERRORS +The +.Fn acl_get_tag_type +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry; +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_create_entry 3 , +.Xr acl_get_entry 3 , +.Xr acl_get_qualifier 3 , +.Xr acl_init 3 , +.Xr acl_set_qualifier 3 , +.Xr acl_set_tag_type 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_tag_type +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_tag_type +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_init.3 b/lib/libc/posix1e/acl_init.3 new file mode 100644 index 0000000..65b2b61 --- /dev/null +++ b/lib/libc/posix1e/acl_init.3 @@ -0,0 +1,109 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_init.3,v 1.14 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd January 28, 2000 +.Dt ACL_INIT 3 +.Os +.Sh NAME +.Nm acl_init +.Nd initialize ACL working storage +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft acl_t +.Fn acl_init "int count" +.Sh DESCRIPTION +The +.Fn acl_init +function allocates and initializes the working storage for an ACL of at +least +.Va count +ACL entries. +A pointer to the working storage is returned. +The working +storage allocated to contain the ACL is freed by a call to +.Xr acl_free 3 . +When the area is first allocated, it shall contain an ACL that contains +no ACL entries. +.Pp +This function may cause memory to be allocated. +The caller should free any +releasable memory, when the new ACL is no longer required, by calling +.Xr acl_free 3 +with the +.Va (void*)acl_t +as an argument. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +Upon successful completion, this function shall return a pointer to the +working storage. +Otherwise, a value of +.Va (acl_t)NULL +shall be returned, and +.Va errno +shall be set to indicate the error. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_init +function shall return a value of +.Va (acl_t)NULL +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +The value of count is less than zero. +.It Bq Er ENOMEM +The +.Va acl_t +to be returned requires more memory than is allowed by the hardware or +system-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_free 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_init.c b/lib/libc/posix1e/acl_init.c new file mode 100644 index 0000000..e38603f --- /dev/null +++ b/lib/libc/posix1e/acl_init.c @@ -0,0 +1,74 @@ +/* + * Copyright (c) 1999, 2000, 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_init.c,v 1.10 2002/03/22 21:52:38 obrien Exp $ + */ + +/* + * acl_init -- return a fresh acl structure + * acl_dup -- duplicate an acl and return the new copy + */ + +#include +#include +#include +#include +#include + +acl_t +acl_init(int count) +{ + acl_t acl; + + if (count > ACL_MAX_ENTRIES) { + errno = ENOMEM; + return (NULL); + } + if (count < 0) { + errno = EINVAL; + return (NULL); + } + + acl = malloc(sizeof(struct acl_t_struct)); + if (acl != NULL) + bzero(acl, sizeof(struct acl_t_struct)); + + return (acl); +} + +acl_t +acl_dup(acl_t acl) +{ + acl_t acl_new; + + acl_new = acl_init(ACL_MAX_ENTRIES); + if (acl_new != NULL) { + *acl_new = *acl; + acl->ats_cur_entry = 0; + acl_new->ats_cur_entry = 0; + } + + return (acl_new); +} diff --git a/lib/libc/posix1e/acl_perm.c b/lib/libc/posix1e/acl_perm.c new file mode 100644 index 0000000..4939ed0 --- /dev/null +++ b/lib/libc/posix1e/acl_perm.c @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: acl_perm.c,v 1.6 2002/03/22 21:52:38 obrien Exp $ + */ + +#include +#include + +#include +#include + +/* + * acl_add_perm() (23.4.1): add the permission contained in perm to the + * permission set permset_d + */ +int +acl_add_perm(acl_permset_t permset_d, acl_perm_t perm) +{ + + if (permset_d) { + switch(perm) { + case ACL_READ: + case ACL_WRITE: + case ACL_EXECUTE: + *permset_d |= perm; + return (0); + } + } + + errno = EINVAL; + return (-1); +} + +/* + * acl_clear_perms() (23.4.3): clear all permisions from the permission + * set permset_d + */ +int +acl_clear_perms(acl_permset_t permset_d) +{ + + if (permset_d == NULL) { + errno = EINVAL; + return (-1); + } + + *permset_d = ACL_PERM_NONE; + + return (0); +} + +/* + * acl_delete_perm() (23.4.10): remove the permission in perm from the + * permission set permset_d + */ +int +acl_delete_perm(acl_permset_t permset_d, acl_perm_t perm) +{ + + if (permset_d) { + switch(perm) { + case ACL_READ: + case ACL_WRITE: + case ACL_EXECUTE: + *permset_d &= ~(perm & ACL_PERM_BITS); + return (0); + } + } + + errno = EINVAL; + return (-1); +} diff --git a/lib/libc/posix1e/acl_set.3 b/lib/libc/posix1e/acl_set.3 new file mode 100644 index 0000000..55c70e8 --- /dev/null +++ b/lib/libc/posix1e/acl_set.3 @@ -0,0 +1,140 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_set.3,v 1.17 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd December 29, 2002 +.Dt ACL_SET 3 +.Os +.Sh NAME +.Nm acl_set_fd , +.Nm acl_set_fd_np , +.Nm acl_set_file , +.Nm acl_set_link_np +.Nd set an ACL for a file +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_set_fd "int fd" "acl_t acl" +.Ft int +.Fn acl_set_fd_np "int fd" "acl_t acl" "acl_type_t type" +.Ft int +.Fn acl_set_file "const char *path_p" "acl_type_t type" "acl_t acl" +.Ft int +.Fn acl_set_link_np "const char *path_p" "acl_type_t type" "acl_t acl" +.Sh DESCRIPTION +The +.Fn acl_set_fd , +.Fn acl_set_fd_np , +.Fn acl_set_file , +and +.Fn acl_set_link_np +each associate an ACL with an object referred to by +.Va fd +or +.Va path_p . +The +.Fn acl_set_fd_np +and +.Fn acl_set_link_np +functions are not POSIX.1e calls. +The +.Fn acl_set_fd +function allows only the setting of ACLs of type ACL_TYPE_ACCESS +where as +.Fn acl_set_fd_np +allows the setting of ACLs of any type. +The +.Fn acl_set_link_np +function acts on a symlink rather than its target, if the target of the +path is a symlink. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +.Rv -std acl_set +.Sh ERRORS +If any of the following conditions occur, these functions shall return +-1 and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EACCES +Search permission is denied for a component of the path prefix, or the +object exists and the process does not have appropriate access rights. +.It Bq Er EBADF +The +.Va fd +argument is not a valid file descriptor. +.It Bq Er EINVAL +Argument +.Va acl +does not point to a valid ACL for this object, or the ACL type +specified in +.Va type +is invalid for this object, or both. +.It Bq Er ENAMETOOLONG +A component of a pathname exceeded 255 characters, or an +entire path name exceeded 1023 characters. +.It Bq Er ENOENT +The named object does not exist, or the +.Va path_p +argument points to an empty string. +.It Bq Er ENOMEM +Insufficient memory available to fulfill request. +.It Bq Er ENOSPC +The directory or file system that would contain the new ACL cannot be +extended, or the file system is out of file allocation resources. +.It Bq Er EOPNOTSUPP +The file system does not support ACL retrieval. +.It Bq Er EROFS +This function requires modification of a file system which is currently +read-only. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_delete 3 , +.Xr acl_get 3 , +.Xr acl_valid 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_set.c b/lib/libc/posix1e/acl_set.c new file mode 100644 index 0000000..dbcbd37 --- /dev/null +++ b/lib/libc/posix1e/acl_set.c @@ -0,0 +1,197 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_set.c,v 1.12 2002/12/29 20:47:05 rwatson Exp $ + */ + +/* + * acl_set_file -- set a file/directory ACL by name + */ + +#include +#include + +#include +#include +#include + +#include "acl_support.h" + +/* + * For POSIX.1e-semantic ACLs, do a presort so the kernel doesn't have to + * (the POSIX.1e semantic code will reject unsorted ACL submission). If it's + * not a semantic that the library knows about, just submit it flat and + * assume the caller knows what they're up to. + */ +int +acl_set_file(const char *path_p, acl_type_t type, acl_t acl) +{ + int error; + + if (acl == NULL || path_p == NULL) { + errno = EINVAL; + return (-1); + } + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + acl->ats_cur_entry = 0; + + return (__acl_set_file(path_p, type, &acl->ats_acl)); +} + +int +acl_set_link_np(const char *path_p, acl_type_t type, acl_t acl) +{ + int error; + + if (acl == NULL || path_p == NULL) { + errno = EINVAL; + return (-1); + } + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + acl->ats_cur_entry = 0; + + return (__acl_set_link(path_p, type, &acl->ats_acl)); +} + +int +acl_set_fd(int fd, acl_t acl) +{ + int error; + + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return(-1); + } + + acl->ats_cur_entry = 0; + + return (__acl_set_fd(fd, ACL_TYPE_ACCESS, &acl->ats_acl)); +} + +int +acl_set_fd_np(int fd, acl_t acl, acl_type_t type) +{ + int error; + + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + acl->ats_cur_entry = 0; + + return (__acl_set_fd(fd, type, &acl->ats_acl)); +} + +/* + * acl_set_permset() (23.4.23): sets the permissions of ACL entry entry_d + * with the permissions in permset_d + */ +int +acl_set_permset(acl_entry_t entry_d, acl_permset_t permset_d) +{ + + if (!entry_d) { + errno = EINVAL; + return (-1); + } + + entry_d->ae_perm = *permset_d; + + return (0); +} + +/* + * acl_set_qualifier() sets the qualifier (ae_id) of the tag for + * ACL entry entry_d to the value referred to by tag_qualifier_p + */ +int +acl_set_qualifier(acl_entry_t entry_d, const void *tag_qualifier_p) +{ + if (!entry_d || !tag_qualifier_p) { + errno = EINVAL; + return (-1); + } + + switch(entry_d->ae_tag) { + case ACL_USER: + case ACL_GROUP: + entry_d->ae_id = *(uid_t *)tag_qualifier_p; + break; + default: + errno = EINVAL; + return (-1); + } + + return (0); +} + +/* + * acl_set_tag_type() sets the tag type for ACL entry entry_d to the + * value of tag_type + */ +int +acl_set_tag_type(acl_entry_t entry_d, acl_tag_t tag_type) +{ + + if (entry_d == NULL) { + errno = EINVAL; + return (-1); + } + + switch(tag_type) { + case ACL_USER_OBJ: + case ACL_USER: + case ACL_GROUP_OBJ: + case ACL_GROUP: + case ACL_MASK: + case ACL_OTHER: + entry_d->ae_tag = tag_type; + return (0); + } + + errno = EINVAL; + return (-1); +} diff --git a/lib/libc/posix1e/acl_set_permset.3 b/lib/libc/posix1e/acl_set_permset.3 new file mode 100644 index 0000000..a23703e --- /dev/null +++ b/lib/libc/posix1e/acl_set_permset.3 @@ -0,0 +1,79 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_set_permset.3,v 1.6 2002/12/18 12:45:09 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_SET_PERMSET 3 +.Os +.Sh NAME +.Nm acl_set_permset +.Nd set the permissions of an ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_set_permset "acl_entry_t entry_d" "acl_permset_t permset_d" +.Sh DESCRIPTION +The +.Fn acl_set_permset +function +is a POSIX.1e call that sets the permissions of ACL entry +.Fa entry_d +with the permissions contained in +.Fa permset_d . +.Sh RETURN VALUES +.Rv -std acl_set_permset +.Sh ERRORS +The +.Fn acl_set_permset +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_add_perm 3 , +.Xr acl_clear_perms 3 , +.Xr acl_delete_perm 3 , +.Xr acl_get_permset 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_set_permset +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_set_permset +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_set_qualifier.3 b/lib/libc/posix1e/acl_set_qualifier.3 new file mode 100644 index 0000000..4994414 --- /dev/null +++ b/lib/libc/posix1e/acl_set_qualifier.3 @@ -0,0 +1,89 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_set_qualifier.3,v 1.6 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_SET_QUALIFIER 3 +.Os +.Sh NAME +.Nm acl_set_qualifier +.Nd set ACL tag qualifier +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_set_qualifier "acl_entry_t entry_d" "const void *tag_qualifier_p" +.Sh DESCRIPTION +The +.Fn acl_set_qualifier +function +is a POSIX.1e call that sets the qualifier of the tag for the ACl entry +.Fa entry_d +to the value referred to by +.Fa tag_qualifier_p . +.Sh RETURN VALUES +.Rv -std acl_set_qualifier +.Sh ERRORS +The +.Fn acl_set_qualifier +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry. +The tag type of the +ACL entry +.Fa entry_d +is not +.Dv ACL_USER +or +.Dv ACL_GROUP . +The value pointed to by +.Fa tag_qualifier_p +is not valid. +.It Bq Er ENOMEM +The value to be returned requires more memory than is allowed +by the hardware or system-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get_qualifier 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_get_qualifier +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_get_qualifier +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_set_tag_type.3 b/lib/libc/posix1e/acl_set_tag_type.3 new file mode 100644 index 0000000..28c69e0 --- /dev/null +++ b/lib/libc/posix1e/acl_set_tag_type.3 @@ -0,0 +1,79 @@ +.\" +.\" Copyright (c) 2001 Chris D. Faulhaber +.\" 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. +.\" +.\" $FreeBSD: acl_set_tag_type.3,v 1.7 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd March 10, 2001 +.Dt ACL_SET_TAG_TYPE 3 +.Os +.Sh NAME +.Nm acl_set_tag_type +.Nd set the tag type of an ACL entry +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_set_tag_type "acl_entry_t entry_d" "acl_tag_t tag_type" +.Sh DESCRIPTION +The +.Fn acl_set_tag_type +function +is a POSIX.1e call that sets the ACL tag type of ACL entry +.Fa entry_d +to the value of +.Fa tag_type . +.Sh RETURN VALUES +.Rv -std acl_set_tag_type +.Sh ERRORS +The +.Fn acl_set_tag_type +function fails if: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Fa entry_d +is not a valid descriptor for an ACL entry. +Argument +.Fa tag_type +is not a valid ACL tag type. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get_tag_type 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 . +The +.Fn acl_set_tag_type +function was added in +.Fx 5.0 . +.Sh AUTHORS +The +.Fn acl_set_tag_type +function was written by +.An Chris D. Faulhaber Aq jedgar@fxp.org . diff --git a/lib/libc/posix1e/acl_size.c b/lib/libc/posix1e/acl_size.c new file mode 100644 index 0000000..bd11b95 --- /dev/null +++ b/lib/libc/posix1e/acl_size.c @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2001-2002 Chris D. Faulhaber + * 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 AND CONTRIBUTORS ``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 OR THE VOICES IN HIS HEAD 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. + * + * $FreeBSD: acl_size.c,v 1.4 2002/03/22 21:52:38 obrien Exp $ + */ + +#include +#include + +#include + +ssize_t +acl_size(acl_t acl) +{ + errno = ENOSYS; + return (-1); +} diff --git a/lib/libc/posix1e/acl_support.c b/lib/libc/posix1e/acl_support.c new file mode 100644 index 0000000..213c3fb --- /dev/null +++ b/lib/libc/posix1e/acl_support.c @@ -0,0 +1,382 @@ +/* + * Copyright (c) 1999, 2000, 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_support.c,v 1.14 2007/02/26 02:07:02 kientzle Exp $ + */ + +/* + * Support functionality for the POSIX.1e ACL interface + * These calls are intended only to be called within the library. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "acl_support.h" + +#define ACL_STRING_PERM_WRITE 'w' +#define ACL_STRING_PERM_READ 'r' +#define ACL_STRING_PERM_EXEC 'x' +#define ACL_STRING_PERM_NONE '-' + +/* + * _posix1e_acl_entry_compare -- compare two acl_entry structures to + * determine the order they should appear in. Used by _posix1e_acl_sort to + * sort ACL entries into the kernel-desired order -- i.e., the order useful + * for evaluation and O(n) validity checking. Beter to have an O(nlogn) sort + * in userland and an O(n) in kernel than to have both in kernel. + */ +typedef int (*compare)(const void *, const void *); +static int +_posix1e_acl_entry_compare(struct acl_entry *a, struct acl_entry *b) +{ + /* + * First, sort between tags -- conveniently defined in the correct + * order for verification. + */ + if (a->ae_tag < b->ae_tag) + return (-1); + if (a->ae_tag > b->ae_tag) + return (1); + + /* + * Next compare uids/gids on appropriate types. + */ + + if (a->ae_tag == ACL_USER || a->ae_tag == ACL_GROUP) { + if (a->ae_id < b->ae_id) + return (-1); + if (a->ae_id > b->ae_id) + return (1); + + /* shouldn't be equal, fall through to the invalid case */ + } + + /* + * Don't know how to sort multiple entries of the rest--either it's + * a bad entry, or there shouldn't be more than one. Ignore and the + * validity checker can get it later. + */ + return (0); +} + +/* + * _posix1e_acl_sort -- sort ACL entries in POSIX.1e-formatted ACLs + * Give the opportunity to fail, although we don't currently have a way + * to fail. + */ +int +_posix1e_acl_sort(acl_t acl) +{ + struct acl *acl_int; + + acl_int = &acl->ats_acl; + + qsort(&acl_int->acl_entry[0], acl_int->acl_cnt, + sizeof(struct acl_entry), (compare) _posix1e_acl_entry_compare); + + return (0); +} + +/* + * acl_posix1e -- in what situations should we acl_sort before submission? + * We apply posix1e ACL semantics for any ACL of type ACL_TYPE_ACCESS or + * ACL_TYPE_DEFAULT + */ +int +_posix1e_acl(acl_t acl, acl_type_t type) +{ + + return ((type == ACL_TYPE_ACCESS) || (type == ACL_TYPE_DEFAULT)); +} + +/* + * _posix1e_acl_check -- given an ACL, check its validity. This is mirrored + * from code in sys/kern/kern_acl.c, and if changes are made in one, they + * should be made in the other also. This copy of acl_check is made + * available * in userland for the benefit of processes wanting to check ACLs + * for validity before submitting them to the kernel, or for performing + * in userland file system checking. Needless to say, the kernel makes + * the real checks on calls to get/setacl. + * + * See the comments in kernel for explanation -- just briefly, it assumes + * an already sorted ACL, and checks based on that assumption. The + * POSIX.1e interface, acl_valid(), will perform the sort before calling + * this. Returns 0 on success, EINVAL on failure. + */ +int +_posix1e_acl_check(acl_t acl) +{ + struct acl *acl_int; + struct acl_entry *entry; /* current entry */ + uid_t obj_uid=-1, obj_gid=-1, highest_uid=0, highest_gid=0; + int stage = ACL_USER_OBJ; + int i = 0; + int count_user_obj=0, count_user=0, count_group_obj=0, + count_group=0, count_mask=0, count_other=0; + + acl_int = &acl->ats_acl; + + /* printf("_posix1e_acl_check: checking acl with %d entries\n", + acl->acl_cnt); */ + while (i < acl_int->acl_cnt) { + entry = &acl_int->acl_entry[i]; + + if ((entry->ae_perm | ACL_PERM_BITS) != ACL_PERM_BITS) + return (EINVAL); + + switch(entry->ae_tag) { + case ACL_USER_OBJ: + /* printf("_posix1e_acl_check: %d: ACL_USER_OBJ\n", + i); */ + if (stage > ACL_USER_OBJ) + return (EINVAL); + stage = ACL_USER; + count_user_obj++; + obj_uid = entry->ae_id; + break; + + case ACL_USER: + /* printf("_posix1e_acl_check: %d: ACL_USER\n", i); */ + if (stage > ACL_USER) + return (EINVAL); + stage = ACL_USER; + if (entry->ae_id == obj_uid) + return (EINVAL); + if (count_user && (entry->ae_id <= highest_uid)) + return (EINVAL); + highest_uid = entry->ae_id; + count_user++; + break; + + case ACL_GROUP_OBJ: + /* printf("_posix1e_acl_check: %d: ACL_GROUP_OBJ\n", + i); */ + if (stage > ACL_GROUP_OBJ) + return (EINVAL); + stage = ACL_GROUP; + count_group_obj++; + obj_gid = entry->ae_id; + break; + + case ACL_GROUP: + /* printf("_posix1e_acl_check: %d: ACL_GROUP\n", i); */ + if (stage > ACL_GROUP) + return (EINVAL); + stage = ACL_GROUP; + if (entry->ae_id == obj_gid) + return (EINVAL); + if (count_group && (entry->ae_id <= highest_gid)) + return (EINVAL); + highest_gid = entry->ae_id; + count_group++; + break; + + case ACL_MASK: + /* printf("_posix1e_acl_check: %d: ACL_MASK\n", i); */ + if (stage > ACL_MASK) + return (EINVAL); + stage = ACL_MASK; + count_mask++; + break; + + case ACL_OTHER: + /* printf("_posix1e_acl_check: %d: ACL_OTHER\n", i); */ + if (stage > ACL_OTHER) + return (EINVAL); + stage = ACL_OTHER; + count_other++; + break; + + default: + /* printf("_posix1e_acl_check: %d: INVALID\n", i); */ + return (EINVAL); + } + i++; + } + + if (count_user_obj != 1) + return (EINVAL); + + if (count_group_obj != 1) + return (EINVAL); + + if (count_mask != 0 && count_mask != 1) + return (EINVAL); + + if (count_other != 1) + return (EINVAL); + + return (0); +} + + +/* + * Given a uid/gid, return a username/groupname for the text form of an ACL. + * Note that we truncate user and group names, rather than error out, as + * this is consistent with other tools manipulating user and group names. + * XXX NOT THREAD SAFE, RELIES ON GETPWUID, GETGRGID + * XXX USES *PW* AND *GR* WHICH ARE STATEFUL AND THEREFORE THIS ROUTINE + * MAY HAVE SIDE-EFFECTS + */ +int +_posix1e_acl_id_to_name(acl_tag_t tag, uid_t id, ssize_t buf_len, char *buf) +{ + struct group *g; + struct passwd *p; + int i; + + switch(tag) { + case ACL_USER: + p = getpwuid(id); + if (!p) + i = snprintf(buf, buf_len, "%d", id); + else + i = snprintf(buf, buf_len, "%s", p->pw_name); + + if (i < 0) { + errno = ENOMEM; + return (-1); + } + return (0); + + case ACL_GROUP: + g = getgrgid(id); + if (g == NULL) + i = snprintf(buf, buf_len, "%d", id); + else + i = snprintf(buf, buf_len, "%s", g->gr_name); + + if (i < 0) { + errno = ENOMEM; + return (-1); + } + return (0); + + default: + return (EINVAL); + } +} + +/* + * Given a right-shifted permission (i.e., direct ACL_PERM_* mask), fill + * in a string describing the permissions. + */ +int +_posix1e_acl_perm_to_string(acl_perm_t perm, ssize_t buf_len, char *buf) +{ + + if (buf_len < _POSIX1E_ACL_STRING_PERM_MAXSIZE + 1) { + errno = ENOMEM; + return (-1); + } + + if ((perm | ACL_PERM_BITS) != ACL_PERM_BITS) { + errno = EINVAL; + return (-1); + } + + buf[3] = 0; /* null terminate */ + + if (perm & ACL_READ) + buf[0] = ACL_STRING_PERM_READ; + else + buf[0] = ACL_STRING_PERM_NONE; + + if (perm & ACL_WRITE) + buf[1] = ACL_STRING_PERM_WRITE; + else + buf[1] = ACL_STRING_PERM_NONE; + + if (perm & ACL_EXECUTE) + buf[2] = ACL_STRING_PERM_EXEC; + else + buf[2] = ACL_STRING_PERM_NONE; + + return (0); +} + +/* + * given a string, return a permission describing it + */ +int +_posix1e_acl_string_to_perm(char *string, acl_perm_t *perm) +{ + acl_perm_t myperm = ACL_PERM_NONE; + char *ch; + + ch = string; + while (*ch) { + switch(*ch) { + case ACL_STRING_PERM_READ: + myperm |= ACL_READ; + break; + case ACL_STRING_PERM_WRITE: + myperm |= ACL_WRITE; + break; + case ACL_STRING_PERM_EXEC: + myperm |= ACL_EXECUTE; + break; + case ACL_STRING_PERM_NONE: + break; + default: + return (EINVAL); + } + ch++; + } + + *perm = myperm; + return (0); +} + +/* + * Add an ACL entry without doing much checking, et al + */ +int +_posix1e_acl_add_entry(acl_t acl, acl_tag_t tag, uid_t id, acl_perm_t perm) +{ + struct acl *acl_int; + struct acl_entry *e; + + acl_int = &acl->ats_acl; + + if (acl_int->acl_cnt >= ACL_MAX_ENTRIES) { + errno = ENOMEM; + return (-1); + } + + e = &(acl_int->acl_entry[acl_int->acl_cnt]); + e->ae_perm = perm; + e->ae_tag = tag; + e->ae_id = id; + acl_int->acl_cnt++; + + return (0); +} diff --git a/lib/libc/posix1e/acl_support.h b/lib/libc/posix1e/acl_support.h new file mode 100644 index 0000000..f7d19a1 --- /dev/null +++ b/lib/libc/posix1e/acl_support.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 1999, 2000, 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_support.h,v 1.5 2007/02/26 02:07:02 kientzle Exp $ + */ + +/* + * Support functionality for the POSIX.1e ACL interface + * These calls are intended only to be called within the library. + */ +#ifndef _ACL_SUPPORT_H +#define _ACL_SUPPORT_H + +#define _POSIX1E_ACL_STRING_PERM_MAXSIZE 3 /* read, write, exec */ + +int _posix1e_acl_check(acl_t acl); +int _posix1e_acl_sort(acl_t acl); +int _posix1e_acl(acl_t acl, acl_type_t type); +int _posix1e_acl_id_to_name(acl_tag_t tag, uid_t id, ssize_t buf_len, + char *buf); +int _posix1e_acl_perm_to_string(acl_perm_t perm, ssize_t buf_len, + char *buf); +int _posix1e_acl_string_to_perm(char *string, acl_perm_t *perm); +int _posix1e_acl_add_entry(acl_t acl, acl_tag_t tag, uid_t id, + acl_perm_t perm); + +#endif diff --git a/lib/libc/posix1e/acl_to_text.3 b/lib/libc/posix1e/acl_to_text.3 new file mode 100644 index 0000000..5a9b826 --- /dev/null +++ b/lib/libc/posix1e/acl_to_text.3 @@ -0,0 +1,139 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_to_text.3,v 1.16 2004/07/02 23:52:11 ru Exp $ +.\" +.Dd January 28, 2000 +.Dt ACL_TO_TEXT 3 +.Os +.Sh NAME +.Nm acl_to_text +.Nd convert an ACL to text +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft char * +.Fn acl_to_text "acl_t acl" "ssize_t *len_p" +.Sh DESCRIPTION +The +.Fn acl_to_text +function translates the ACL pointed to by argument +.Va acl +into a NULL terminated character string. +If the pointer +.Va len_p +is not NULL, then the function shall return the length of the string (not +including the NULL terminator) in the location pointed to by +.Va len_p . +The format of the text string returned by +.Fn acl_to_text +shall be the POSIX.1e long ACL form. +.Pp +This function allocates any memory necessary to contain the string and +returns a pointer to the string. +The caller should free any releasable +memory, when the new string is no longer required, by calling +.Xr acl_free 3 +with the +.Va (void*)char +as an argument. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +Upon successful completion, the function shall return a pointer to the +long text form of an ACL. +Otherwise, a value of +.Va (char*)NULL +shall be returned and +.Va errno +shall be set to indicate the error. +.Sh ERRORS +If any of the following conditions occur, the +.Fn acl_to_text +function shall return a value of +.Va (acl_t)NULL +and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EINVAL +Argument +.Va acl +does not point to a valid ACL. +.Pp +The ACL denoted by +.Va acl +contains one or more improperly formed ACL entries, or for some other +reason cannot be translated into a text form of an ACL. +.It Bq Er ENOMEM +The character string to be returned requires more memory than is allowed +by the hardware or software-imposed memory management constraints. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_free 3 , +.Xr acl_from_text 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson +.Sh BUGS +The +.Fn acl_from_text +and +.Fn acl_to_text +functions +rely on the +.Xr getpwent 3 +library calls to manage username and uid mapping, as well as the +.Xr getgrent 3 +library calls to manage groupname and gid mapping. +These calls are not +thread safe, and so transitively, neither are +.Fn acl_from_text +and +.Fn acl_to_text . +These functions may also interfere with stateful +calls associated with the +.Fn getpwent +and +.Fn getgrent +calls. diff --git a/lib/libc/posix1e/acl_to_text.c b/lib/libc/posix1e/acl_to_text.c new file mode 100644 index 0000000..567ab8f --- /dev/null +++ b/lib/libc/posix1e/acl_to_text.c @@ -0,0 +1,235 @@ +/* + * Copyright (c) 1999-2002 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_to_text.c,v 1.11 2003/07/24 23:33:25 rwatson Exp $ + */ + +/* + * acl_to_text - return a text string with a text representation of the acl + * in it. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "acl_support.h" + +/* + * acl_to_text - generate a text form of an acl + * spec says nothing about output ordering, so leave in acl order + * + * This function will not produce nice results if it is called with + * a non-POSIX.1e semantics ACL. + */ +char * +acl_to_text(acl_t acl, ssize_t *len_p) +{ + struct acl *acl_int; + char *buf, *tmpbuf; + char name_buf[UT_NAMESIZE+1]; + char perm_buf[_POSIX1E_ACL_STRING_PERM_MAXSIZE+1], + effective_perm_buf[_POSIX1E_ACL_STRING_PERM_MAXSIZE+1]; + int i, error, len; + uid_t ae_id; + acl_tag_t ae_tag; + acl_perm_t ae_perm, effective_perm, mask_perm; + + buf = strdup(""); + if (buf == NULL) + return(NULL); + + if (acl == NULL) { + errno = EINVAL; + return(NULL); + } + + acl_int = &acl->ats_acl; + + mask_perm = ACL_PERM_BITS; /* effective is regular if no mask */ + for (i = 0; i < acl_int->acl_cnt; i++) + if (acl_int->acl_entry[i].ae_tag == ACL_MASK) + mask_perm = acl_int->acl_entry[i].ae_perm; + + for (i = 0; i < acl_int->acl_cnt; i++) { + ae_tag = acl_int->acl_entry[i].ae_tag; + ae_id = acl_int->acl_entry[i].ae_id; + ae_perm = acl_int->acl_entry[i].ae_perm; + + switch(ae_tag) { + case ACL_USER_OBJ: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + len = asprintf(&tmpbuf, "%suser::%s\n", buf, + perm_buf); + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + case ACL_USER: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + + error = _posix1e_acl_id_to_name(ae_tag, ae_id, + UT_NAMESIZE+1, name_buf); + if (error) + goto error_label; + + effective_perm = ae_perm & mask_perm; + if (effective_perm != ae_perm) { + error = _posix1e_acl_perm_to_string( + effective_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, + effective_perm_buf); + if (error) + goto error_label; + len = asprintf(&tmpbuf, "%suser:%s:%s\t\t# " + "effective: %s\n", + buf, name_buf, perm_buf, + effective_perm_buf); + } else { + len = asprintf(&tmpbuf, "%suser:%s:%s\n", buf, + name_buf, perm_buf); + } + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + case ACL_GROUP_OBJ: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + + effective_perm = ae_perm & mask_perm; + if (effective_perm != ae_perm) { + error = _posix1e_acl_perm_to_string( + effective_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, + effective_perm_buf); + if (error) + goto error_label; + len = asprintf(&tmpbuf, "%sgroup::%s\t\t# " + "effective: %s\n", + buf, perm_buf, effective_perm_buf); + } else { + len = asprintf(&tmpbuf, "%sgroup::%s\n", buf, + perm_buf); + } + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + case ACL_GROUP: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + + error = _posix1e_acl_id_to_name(ae_tag, ae_id, + UT_NAMESIZE+1, name_buf); + if (error) + goto error_label; + + effective_perm = ae_perm & mask_perm; + if (effective_perm != ae_perm) { + error = _posix1e_acl_perm_to_string( + effective_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, + effective_perm_buf); + if (error) + goto error_label; + len = asprintf(&tmpbuf, "%sgroup:%s:%s\t\t# " + "effective: %s\n", + buf, name_buf, perm_buf, + effective_perm_buf); + } else { + len = asprintf(&tmpbuf, "%sgroup:%s:%s\n", buf, + name_buf, perm_buf); + } + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + case ACL_MASK: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + + len = asprintf(&tmpbuf, "%smask::%s\n", buf, + perm_buf); + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + case ACL_OTHER: + error = _posix1e_acl_perm_to_string(ae_perm, + _POSIX1E_ACL_STRING_PERM_MAXSIZE+1, perm_buf); + if (error) + goto error_label; + + len = asprintf(&tmpbuf, "%sother::%s\n", buf, + perm_buf); + if (len == -1) + goto error_label; + free(buf); + buf = tmpbuf; + break; + + default: + errno = EINVAL; + goto error_label; + } + } + + if (len_p) { + *len_p = strlen(buf); + } + return (buf); + +error_label: + /* jump to here sets errno already, we just clean up */ + if (buf) free(buf); + return (NULL); +} diff --git a/lib/libc/posix1e/acl_valid.3 b/lib/libc/posix1e/acl_valid.3 new file mode 100644 index 0000000..3b2ff00 --- /dev/null +++ b/lib/libc/posix1e/acl_valid.3 @@ -0,0 +1,168 @@ +.\" +.\" Copyright (c) 2000, 2002 Robert N. M. Watson +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: acl_valid.3,v 1.16 2005/01/15 12:21:03 ru Exp $ +.\" +.Dd December 29, 2002 +.Dt ACL_VALID 3 +.Os +.Sh NAME +.Nm acl_valid , +.Nm acl_valid_fd_np , +.Nm acl_valid_file_np , +.Nm acl_valid_link_np +.Nd validate an ACL +.Sh SYNOPSIS +.In sys/types.h +.In sys/acl.h +.Ft int +.Fn acl_valid "acl_t acl" +.Ft int +.Fn acl_valid_fd_np "int fd" "acl_type_t type" "acl_t acl" +.Ft int +.Fn acl_valid_file_np "const char *path_p" "acl_type_t type" "acl_t acl" +.Ft int +.Fn acl_valid_link_np "const char *path_p" "acl_type_t type" "acl_t acl" +.Sh DESCRIPTION +These functions check that the ACL referred to by the argument +.Va acl +is valid. +The POSIX.1e routine, +.Fn acl_valid , +checks this validity only with POSIX.1e ACL semantics, and irrespective +of the context in which the ACL is to be used. +The non-portable forms, +.Fn acl_valid_fd_np , +.Fn acl_valid_file_np , +and +.Fn acl_valid_link_np +allow an ACL to be checked in the context of a specific acl type, +.Va type , +and file system object. +In environments where additional ACL types are +supported than just POSIX.1e, this makes more sense. +Whereas +.Fn acl_valid_file_np +will follow the symlink if the specified path is to a symlink, +.Fn acl_valid_link_np +will not. +.Pp +For POSIX.1e semantics, the checks include: +.Bl -bullet +.It +The three required entries +.Dv ( ACL_USER_OBJ , ACL_GROUP_OBJ , +and +.Dv ACL_OTHER ) +shall exist exactly once in the ACL. +If the ACL contains any +.Dv ACL_USER , ACL_GROUP , +or any other +implementation-defined entries in the file group class +then one +.Dv ACL_MASK +entry shall also be required. +The ACL shall contain at most one +.Dv ACL_MASK +entry. +.It +The qualifier field shall be unique among all entries of +the same POSIX.1e ACL facility defined tag type. +The +tag type field shall contain valid values including any +implementation-defined values. +Validation of the values +of the qualifier field is implementation-defined. +.El +.Pp +The POSIX.1e +.Fn acl_valid +function may reorder the ACL for the purposes of verification; the +non-portable validation functions will not. +.Sh IMPLEMENTATION NOTES +.Fx Ns 's +support for POSIX.1e interfaces and features is still under +development at this time. +.Sh RETURN VALUES +.Rv -std acl_valid +.Sh ERRORS +If any of the following conditions occur, these functions shall return +-1 and set +.Va errno +to the corresponding value: +.Bl -tag -width Er +.It Bq Er EACCES +Search permission is denied for a component of the path prefix, or the +object exists and the process does not have appropriate access rights. +.It Bq Er EBADF +The +.Va fd +argument is not a valid file descriptor. +.It Bq Er EINVAL +Argument +.Va acl +does not point to a valid ACL. +.Pp +One or more of the required ACL entries is not present in +.Va acl . +.Pp +The ACL contains entries that are not unique. +.Pp +The file system rejects the ACL based on fs-specific semantics issues. +.It Bq Er ENAMETOOLONG +A component of a pathname exceeded 255 characters, or an +entire path name exceeded 1023 characters. +.It Bq Er ENOENT +The named object does not exist, or the +.Va path_p +argument points to an empty string. +.It Bq Er ENOMEM +Insufficient memory available to fulfill request. +.It Bq Er EOPNOTSUPP +The file system does not support ACL retrieval. +.El +.Sh SEE ALSO +.Xr acl 3 , +.Xr acl_get 3 , +.Xr acl_init 3 , +.Xr acl_set 3 , +.Xr posix1e 3 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion +of the draft continues on the cross-platform POSIX.1e implementation +mailing list. +To join this list, see the +.Fx +POSIX.1e implementation +page for more information. +.Sh HISTORY +POSIX.1e support was introduced in +.Fx 4.0 , +and development continues. +.Sh AUTHORS +.An Robert N M Watson diff --git a/lib/libc/posix1e/acl_valid.c b/lib/libc/posix1e/acl_valid.c new file mode 100644 index 0000000..35f0583 --- /dev/null +++ b/lib/libc/posix1e/acl_valid.c @@ -0,0 +1,134 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: acl_valid.c,v 1.10 2002/12/29 20:47:05 rwatson Exp $ + */ + +/* + * acl_valid -- POSIX.1e ACL check routine + */ + +#include +#include +#include +#include + +#include "acl_support.h" + +/* + * acl_valid: accepts an ACL, returns 0 on valid ACL, -1 for invalid, + * and errno set to EINVAL. + * + * Implemented by calling the acl_check routine in acl_support, which + * requires ordering. We call acl_support's _posix1e_acl_sort to make this + * true. POSIX.1e allows acl_valid() to reorder the ACL as it sees fit. + * + * This call is deprecated, as it doesn't ask whether the ACL is valid + * for a particular target. However, this call is standardized, unlike + * the other two forms. + */ +int +acl_valid(acl_t acl) +{ + int error; + + if (acl == NULL) { + errno = EINVAL; + return (-1); + } + _posix1e_acl_sort(acl); + error = _posix1e_acl_check(acl); + if (error) { + errno = error; + return (-1); + } else { + return (0); + } +} + +int +acl_valid_file_np(const char *pathp, acl_type_t type, acl_t acl) +{ + int error; + + if (pathp == NULL || acl == NULL) { + errno = EINVAL; + return (-1); + } + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + return (__acl_aclcheck_file(pathp, type, &acl->ats_acl)); +} + +int +acl_valid_link_np(const char *pathp, acl_type_t type, acl_t acl) +{ + int error; + + if (pathp == NULL || acl == NULL) { + errno = EINVAL; + return (-1); + } + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + return (__acl_aclcheck_link(pathp, type, &acl->ats_acl)); +} + +int +acl_valid_fd_np(int fd, acl_type_t type, acl_t acl) +{ + int error; + + if (acl == NULL) { + errno = EINVAL; + return (-1); + } + if (_posix1e_acl(acl, type)) { + error = _posix1e_acl_sort(acl); + if (error) { + errno = error; + return (-1); + } + } + + acl->ats_cur_entry = 0; + + + return (__acl_aclcheck_fd(fd, type, &acl->ats_acl)); +} diff --git a/lib/libc/posix1e/extattr.3 b/lib/libc/posix1e/extattr.3 new file mode 100644 index 0000000..2312be7 --- /dev/null +++ b/lib/libc/posix1e/extattr.3 @@ -0,0 +1,83 @@ +.\" +.\" Copyright (c) 2008 GeNUA mbH +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.Dd February 5, 2008 +.Dt EXTATTR 3 +.Os +.Sh NAME +.Nm extattr_namespace_to_string , +.Nm extattr_string_to_namespace +.Nd convert between numeric and alphabetical representations of an extended +attribute namespace +.Sh SYNOPSIS +.In sys/extattr.h +.Ft int +.Fn extattr_namespace_to_string "int attrnamespace" "char **string" +.Ft int +.Fn extattr_string_to_namespace "const char *string" "int *attrnamespace" +.Sh DESCRIPTION +The +.Fn extattr_namespace_to_string +function maps the +.Fa attrnamespace +integer containing an extended attribute namespace identifier code to a +corresponding alphabetical representation in +.Fa string . +Memory for +.Fa string +is allocated dynamically, and it is up to the caller to release it using +.Xr free 3 +when appropriate. +.Pp +The +.Fn extattr_string_to_namespace +function maps the +.Fa string +containing the alphabetical representation of an extended attribute +namespace identifier to a corresponding numeric code in +.Fa attrnamespace . +.Sh RETURN VALUES +If the call succeeds, 0 is returned. +Otherwise, \-1 is returned and +.Va errno +is set to indicate the error. +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EINVAL +The requested namespace could not be identified. +.El +.Sh SEE ALSO +.Xr extattr 2 , +.Xr getextattr 8 , +.Xr setextattr 8 , +.Xr extattr 9 +.Sh CAVEATS +Currently, only the +.Dv EXTATTR_NAMESPACE_USER +.Pq Dq user +and +.Dv EXTATTR_NAMESPACE_SYSTEM +.Pq Dq system +namespaces are supported. diff --git a/lib/libc/posix1e/extattr.c b/lib/libc/posix1e/extattr.c new file mode 100644 index 0000000..948b25d --- /dev/null +++ b/lib/libc/posix1e/extattr.c @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2001 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: extattr.c,v 1.7 2005/09/12 19:52:41 stefanf Exp $ + */ + +/* + * TrustedBSD: Utility functions for extended attributes. + */ + +#include +#include + +#include +#include + +int +extattr_namespace_to_string(int attrnamespace, char **string) +{ + + switch(attrnamespace) { + case EXTATTR_NAMESPACE_USER: + if (string != NULL) + *string = strdup(EXTATTR_NAMESPACE_USER_STRING); + return (0); + + case EXTATTR_NAMESPACE_SYSTEM: + if (string != NULL) + *string = strdup(EXTATTR_NAMESPACE_SYSTEM_STRING); + return (0); + + default: + errno = EINVAL; + return (-1); + } +} + +int +extattr_string_to_namespace(const char *string, int *attrnamespace) +{ + + if (!strcmp(string, EXTATTR_NAMESPACE_USER_STRING)) { + if (attrnamespace != NULL) + *attrnamespace = EXTATTR_NAMESPACE_USER; + return (0); + } else if (!strcmp(string, EXTATTR_NAMESPACE_SYSTEM_STRING)) { + if (attrnamespace != NULL) + *attrnamespace = EXTATTR_NAMESPACE_SYSTEM; + return (0); + } else { + errno = EINVAL; + return (-1); + } +} diff --git a/lib/libc/posix1e/mac.3 b/lib/libc/posix1e/mac.3 new file mode 100644 index 0000000..196d55e --- /dev/null +++ b/lib/libc/posix1e/mac.3 @@ -0,0 +1,188 @@ +.\" Copyright (c) 2001, 2003 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and Network Associates +.\" Laboratories, the Security Research Division of Network Associates, +.\" Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part +.\" of the DARPA CHATS research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac.3,v 1.15 2005/07/31 03:30:44 keramida Exp $ +.\" +.Dd April 19, 2003 +.Dt MAC 3 +.Os +.Sh NAME +.Nm mac +.Nd introduction to the MAC security API +.Sh SYNOPSIS +.In sys/mac.h +.Sh DESCRIPTION +The +.Tn TrustedBSD +MAC Framework permits administrators to define +Mandatory Access Control labels +defining levels for the privacy and integrity of data, +overriding discretionary policies +for those objects. +Not all objects currently provide support for MAC labels, +and MAC support must be explicitly enabled by the administrator. +The library calls include routines to retrieve, duplicate, +and set MAC labels associated with files and processes. +.Pp +POSIX.1e describes a set of MAC manipulation routines +to manage the contents of MAC labels, +as well as their relationships with +files and processes; +almost all of these support routines +are implemented in +.Ox . +.Pp +Available functions, sorted by behavior, include: +.Bl -tag -width indent +.It Fn mac_get_fd +This function is described in +.Xr mac_get 3 , +and may be used to retrieve the +MAC label associated with +a specific file descriptor. +.It Fn mac_get_file +This function is described in +.Xr mac_get 3 , +and may be used to retrieve the +MAC label associated with +a named file. +.It Fn mac_get_proc +This function is described in +.Xr mac_get 3 , +and may be used to retrieve the +MAC label associated with +the calling process. +.It Fn mac_set_fd +This function is described in +.Xr mac_set 3 , +and may be used to set the +MAC label associated with +a specific file descriptor. +.It Fn mac_set_file +This function is described in +.Xr mac_set 3 , +and may be used to set the +MAC label associated with +a named file. +.It Fn mac_set_proc +This function is described in +.Xr mac_set 3 , +and may be used to set the +MAC label associated with +the calling process. +.It Fn mac_free +This function is described in +.Xr mac_free 3 , +and may be used to free +userland working MAC label storage. +.It Fn mac_from_text +This function is described in +.Xr mac_text 3 , +and may be used to convert +a text-form MAC label +into a working +.Vt mac_t . +.It Fn mac_prepare +.It Fn mac_prepare_file_label +.It Fn mac_prepare_ifnet_label +.It Fn mac_prepare_process_label +These functions are described in +.Xr mac_prepare 3 , +and may be used to preallocate storage for MAC label retrieval. +.Xr mac_prepare 3 +prepares a label based on caller-specified label names; the other calls +rely on the default configuration specified in +.Xr mac.conf 5 . +.It Fn mac_to_text +This function is described in +.Xr mac_text 3 , +and may be used to convert a +.Vt mac_t +into a text-form MAC label. +.El +The behavior of some of these calls is influenced by the configuration +settings found in +.Xr mac.conf 5 , +the MAC library run-time configuration file. +.Sh IMPLEMENTATION NOTES +.Ox Ns 's +support for POSIX.1e interfaces and features +is +.Ud . +.Sh FILES +.Bl -tag -width ".Pa /etc/mac.conf" -compact +.It Pa /etc/mac.conf +MAC library configuration file, documented in +.Xr mac.conf 5 . +Provides default behavior for applications aware of MAC labels on +system objects, but without policy-specific knowledge. +.El +.Sh SEE ALSO +.Xr mac_free 3 , +.Xr mac_get 3 , +.Xr mac_prepare 3 , +.Xr mac_set 3 , +.Xr mac_text 3 , +.Xr mac 4 , +.Xr mac.conf 5 , +.Xr mac 9 +.Sh STANDARDS +These APIs are loosely based on the APIs described in POSIX.1e. +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft +continues on the cross-platform POSIX.1e implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page +for more information. +However, the resemblance of these APIs to the POSIX APIs is only loose, +as the POSIX APIs were unable to express many notions required for +flexible and extensible access control. +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. +.Sh BUGS +The +.Tn TrustedBSD +MAC Framework and associated policies, interfaces, and +applications are considered to be an experimental feature in +.Ox . +Sites considering production deployment should keep the experimental +status of these services in mind during any deployment process. +See also +.Xr mac 9 +for related considerations regarding the kernel framework. diff --git a/lib/libc/posix1e/mac.c b/lib/libc/posix1e/mac.c new file mode 100644 index 0000000..41a0d88 --- /dev/null +++ b/lib/libc/posix1e/mac.c @@ -0,0 +1,460 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * Copyright (c) 2002, 2003 Networks Associates Technology, Inc. + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac.c,v 1.13 2008/03/07 15:25:56 rwatson Exp $ + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +static int internal_initialized; + +/* + * Maintain a list of default label preparations for various object + * types. Each name will appear only once in the list. + * + * XXXMAC: Not thread-safe. + */ +static LIST_HEAD(, label_default) label_default_head; +struct label_default { + char *ld_name; + char *ld_labels; + LIST_ENTRY(label_default) ld_entries; +}; + +static void +mac_destroy_labels(void) +{ + struct label_default *ld; + + while ((ld = LIST_FIRST(&label_default_head))) { + free(ld->ld_name); + free(ld->ld_labels); + LIST_REMOVE(ld, ld_entries); + free(ld); + } +} + +static void +mac_destroy_internal(void) +{ + + mac_destroy_labels(); + + internal_initialized = 0; +} + +static int +mac_add_type(const char *name, const char *labels) +{ + struct label_default *ld, *ld_new; + char *name_dup, *labels_dup; + + /* + * Speculatively allocate all the memory now to avoid allocating + * later when we will someday hold a mutex. + */ + name_dup = strdup(name); + if (name_dup == NULL) { + errno = ENOMEM; + return (-1); + } + labels_dup = strdup(labels); + if (labels_dup == NULL) { + free(name_dup); + errno = ENOMEM; + return (-1); + } + ld_new = malloc(sizeof(*ld)); + if (ld_new == NULL) { + free(name_dup); + free(labels_dup); + errno = ENOMEM; + return (-1); + } + + /* + * If the type is already present, replace the current entry + * rather than add a new instance. + */ + for (ld = LIST_FIRST(&label_default_head); ld != NULL; + ld = LIST_NEXT(ld, ld_entries)) { + if (strcmp(name, ld->ld_name) == 0) + break; + } + + if (ld != NULL) { + free(ld->ld_labels); + ld->ld_labels = labels_dup; + labels_dup = NULL; + } else { + ld = ld_new; + ld->ld_name = name_dup; + ld->ld_labels = labels_dup; + + ld_new = NULL; + name_dup = NULL; + labels_dup = NULL; + + LIST_INSERT_HEAD(&label_default_head, ld, ld_entries); + } + + if (name_dup != NULL) + free(name_dup); + if (labels_dup != NULL) + free(labels_dup); + if (ld_new != NULL) + free(ld_new); + + return (0); +} + +static char * +next_token(char **string) +{ + char *token; + + token = strsep(string, " \t"); + while (token != NULL && *token == '\0') + token = strsep(string, " \t"); + + return (token); +} + +static int +mac_init_internal(int ignore_errors) +{ + const char *filename; + char line[LINE_MAX]; + FILE *file; + int error; + + error = 0; + + LIST_INIT(&label_default_head); + + if (!issetugid() && getenv("MAC_CONFFILE") != NULL) + filename = getenv("MAC_CONFFILE"); + else + filename = MAC_CONFFILE; + file = fopen(filename, "r"); + if (file == NULL) + return (0); + + while (fgets(line, LINE_MAX, file)) { + char *comment, *parse, *statement; + + if (line[strlen(line)-1] == '\n') + line[strlen(line)-1] = '\0'; + else { + if (ignore_errors) + continue; + fclose(file); + error = EINVAL; + goto just_return; + } + + /* Remove any comment. */ + comment = line; + parse = strsep(&comment, "#"); + + /* Blank lines OK. */ + statement = next_token(&parse); + if (statement == NULL) + continue; + + if (strcmp(statement, "default_labels") == 0) { + char *name, *labels; + + name = next_token(&parse); + labels = next_token(&parse); + if (name == NULL || labels == NULL || + next_token(&parse) != NULL) { + if (ignore_errors) + continue; + error = EINVAL; + fclose(file); + goto just_return; + } + + if (mac_add_type(name, labels) == -1) { + if (ignore_errors) + continue; + fclose(file); + goto just_return; + } + } else if (strcmp(statement, "default_ifnet_labels") == 0 || + strcmp(statement, "default_file_labels") == 0 || + strcmp(statement, "default_process_labels") == 0) { + char *labels, *type; + + if (strcmp(statement, "default_ifnet_labels") == 0) + type = "ifnet"; + else if (strcmp(statement, "default_file_labels") == 0) + type = "file"; + else if (strcmp(statement, "default_process_labels") == + 0) + type = "process"; + + labels = next_token(&parse); + if (labels == NULL || next_token(&parse) != NULL) { + if (ignore_errors) + continue; + error = EINVAL; + fclose(file); + goto just_return; + } + + if (mac_add_type(type, labels) == -1) { + if (ignore_errors) + continue; + fclose(file); + goto just_return; + } + } else { + if (ignore_errors) + continue; + fclose(file); + error = EINVAL; + goto just_return; + } + } + + fclose(file); + + internal_initialized = 1; + +just_return: + if (error != 0) + mac_destroy_internal(); + return (error); +} + +static int +mac_maybe_init_internal(void) +{ + + if (!internal_initialized) + return (mac_init_internal(1)); + else + return (0); +} + +int +mac_reload(void) +{ + + if (internal_initialized) + mac_destroy_internal(); + return (mac_init_internal(0)); +} + +int +mac_free(struct mac *mac) +{ + + if (mac->m_string != NULL) + free(mac->m_string); + free(mac); + + return (0); +} + +int +mac_from_text(struct mac **mac, const char *text) +{ + + *mac = (struct mac *) malloc(sizeof(**mac)); + if (*mac == NULL) + return (ENOMEM); + + (*mac)->m_string = strdup(text); + if ((*mac)->m_string == NULL) { + free(*mac); + *mac = NULL; + return (ENOMEM); + } + + (*mac)->m_buflen = strlen((*mac)->m_string)+1; + + return (0); +} + +int +mac_to_text(struct mac *mac, char **text) +{ + + *text = strdup(mac->m_string); + if (*text == NULL) + return (ENOMEM); + return (0); +} + +int +mac_prepare(struct mac **mac, const char *elements) +{ + + if (strlen(elements) >= MAC_MAX_LABEL_BUF_LEN) + return (EINVAL); + + *mac = (struct mac *) malloc(sizeof(**mac)); + if (*mac == NULL) + return (ENOMEM); + + (*mac)->m_string = malloc(MAC_MAX_LABEL_BUF_LEN); + if ((*mac)->m_string == NULL) { + free(*mac); + *mac = NULL; + return (ENOMEM); + } + + strcpy((*mac)->m_string, elements); + (*mac)->m_buflen = MAC_MAX_LABEL_BUF_LEN; + + return (0); +} + +int +mac_prepare_type(struct mac **mac, const char *name) +{ + struct label_default *ld; + int error; + + error = mac_maybe_init_internal(); + if (error != 0) + return (error); + + for (ld = LIST_FIRST(&label_default_head); ld != NULL; + ld = LIST_NEXT(ld, ld_entries)) { + if (strcmp(name, ld->ld_name) == 0) + return (mac_prepare(mac, ld->ld_labels)); + } + + errno = ENOENT; + return (-1); /* XXXMAC: ENOLABEL */ +} + +int +mac_prepare_ifnet_label(struct mac **mac) +{ + + return (mac_prepare_type(mac, "ifnet")); +} + +int +mac_prepare_file_label(struct mac **mac) +{ + + return (mac_prepare_type(mac, "file")); +} + +int +mac_prepare_packet_label(struct mac **mac) +{ + + return (mac_prepare_type(mac, "packet")); +} + +int +mac_prepare_process_label(struct mac **mac) +{ + + return (mac_prepare_type(mac, "process")); +} + +#ifdef CTL_SECURITY_NAMES +struct ctlname securityname[] = CTL_SECURITY_NAMES; +#else +struct ctlname securityname[] = { 0, 0 }; +#define SECURITY_MAXID 0 +#endif + +/* + * Simply test whether the TrustedBSD/MAC MIB tree is present; if so, + * return 1 to indicate that the system has MAC enabled overall or for + * a given policy. + */ +int +mac_is_present(const char *policyname) +{ + int error, i, mac_enabled, mac_version, mib[3]; + size_t len; + struct ctlname ctlname; + + if (policyname != NULL) { + for (i = 0; i < SECURITY_MAXID; i++) { + ctlname = securityname[i]; + /* Skip "mac_" and see if the policy name matches. */ + if (strlen(ctlname.ctl_name) < 5) + continue; + if (!strcmp(ctlname.ctl_name + 4, policyname)) + break; + } + if (i == SECURITY_MAXID) { + errno = EINVAL; + return (-1); /* No such policy. */ + } + /* Now do the sysctl(), to see if the policy is active. */ + mib[0] = CTL_SECURITY; + mib[1] = i; + /* XXX PM: EVERY POLICY SHOULD SUPPORT THAT SYSCTL! */ + mib[2] = MAC_POLICY_ENABLED; + len = sizeof(mac_enabled); + error = sysctl(mib, 3, &mac_enabled, &len, NULL, 0); + if (error == -1) + return (-1); + return (mac_enabled); + } else { + mib[0] = CTL_SECURITY; + mib[1] = SECURITY_VERSION; + len = sizeof(mac_version); + error = sysctl(mib, 2, &mac_version, &len, NULL, 0); + if (error == -1) { + if (errno == EOPNOTSUPP) + return (0); /* MAC not present. */ + return (-1); /* Preserve 'errno'. */ + } + return (1); /* MAC present. */ + } +} diff --git a/lib/libc/posix1e/mac.conf.5 b/lib/libc/posix1e/mac.conf.5 new file mode 100644 index 0000000..b0930a7 --- /dev/null +++ b/lib/libc/posix1e/mac.conf.5 @@ -0,0 +1,127 @@ +.\" Copyright (c) 2003 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project in part by Network +.\" Associates Laboratories, the Security Research Division of Network +.\" Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), +.\" as part of the DARPA CHATS research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac.conf.5,v 1.7 2005/01/20 09:17:03 ru Exp $ +.\" +.Dd April 19, 2003 +.Dt MAC.CONF 5 +.Os +.Sh NAME +.Nm mac.conf +.Nd format of the MAC library configuration file +.Sh DESCRIPTION +The +.Nm +file configures the default label elements to be used by policy-agnostic +applications that operate on MAC labels. +A file contains a series of default label sets specified by object class, +in addition to blank lines and comments preceded by a +.Ql # +symbol. +.Pp +Currently, the implementation supports two syntax styles for label +element declaration. +The old (deprecated) syntax consists of a +single line with two fields separated by white space: the object +class name, and a list of label elements as used by the +.Xr mac_prepare 3 +library calls prior to an application invocation of a function from +.Xr mac_get 3 . +.Pp +The newer more preferred syntax consists of three fields separated by +white space: the label group, object class name and a list of +label elements. +.Pp +Label element names may optionally begin with a +.Ql \&? +symbol to indicate that a failure to retrieve the label element for +an object should be silently ignored, and improves usability if the +set of MAC policies may change over time. +.Sh FILES +.Bl -tag -width ".Pa /etc/mac.conf" -compact +.It Pa /etc/mac.conf +MAC library configuration file. +.El +.Sh EXAMPLES +The following example configures user applications to operate with +four MAC policies: +.Xr mac_biba 4 , +.Xr mac_mls 4 , +SEBSD, +and +.Xr mac_partition 4 . +.Bd -literal -offset indent +# +# Default label set to be used by simple MAC applications + +default_labels file ?biba,?lomac,?mls,?sebsd +default_labels ifnet ?biba,?lomac,?mls,?sebsd +default_labels process ?biba,?lomac,?mls,?partition,?sebsd +default_labels socket ?biba,?lomac,?mls + +# +# Deprecated (old) syntax + +default_file_labels ?biba,?mls,?sebsd +default_ifnet_labels ?biba,?mls,?sebsd +default_process_labels ?biba,?mls,partition,?sebsd +.Ed +.Pp +In this example, userland applications will attempt to retrieve Biba, +MLS, and SEBSD labels for all object classes; for processes, they will +additionally attempt to retrieve a Partition identifier. +In all cases except the Partition identifier, failure to retrieve a +label due to the respective policy not being present will be ignored. +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_get 3 , +.Xr mac_prepare 3 , +.Xr mac 4 , +.Xr mac 9 +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. +.Sh BUGS +The +.Tn TrustedBSD +MAC Framework and associated policies, interfaces, and +applications are considered to be an experimental feature in +.Fx . +Sites considering production deployment should keep the experimental +status of these services in mind during any deployment process. +See also +.Xr mac 9 +for related considerations regarding the kernel framework. diff --git a/lib/libc/posix1e/mac_exec.c b/lib/libc/posix1e/mac_exec.c new file mode 100644 index 0000000..ddbf959 --- /dev/null +++ b/lib/libc/posix1e/mac_exec.c @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2002 Networks Associates Technology, Inc. + * All rights reserved. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_exec.c,v 1.3 2008/03/07 15:25:56 rwatson Exp $ + */ + +#include +#include + +extern int __mac_execve(char *fname, char **argv, char **envv, + struct mac *mac_p); + +int +mac_execve(char *fname, char **argv, char **envv, struct mac *label) +{ +#if 0 /* XXX PM: Nothing seems to use this system call. Should we bother? */ + return (__mac_execve(fname, argv, envv, label)); +#else + return (-1); +#endif +} diff --git a/lib/libc/posix1e/mac_free.3 b/lib/libc/posix1e/mac_free.3 new file mode 100644 index 0000000..fb59159 --- /dev/null +++ b/lib/libc/posix1e/mac_free.3 @@ -0,0 +1,100 @@ +.\" Copyright (c) 2001, 2002 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and NAI Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS +.\" research program. +.\" +.\" 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. +.\" 3. The name of the author may not be used to endorse or promote +.\" products derived from this software without specific prior written +.\" permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_free.3,v 1.6 2003/08/22 18:01:03 rwatson Exp $ +.\" +.Dd December 21, 2001 +.Dt MAC_FREE 3 +.Os +.Sh NAME +.Nm mac_free +.Nd free MAC label +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_free "mac_t label" +.Sh DESCRIPTION +The +.Fn mac_free +function frees the storage allocated to contain a +.Vt mac_t . +.Sh RETURN VALUES +The +.Fn mac_free +function always returns 0. +WARNING: see the notes in the +.Sx BUGS +section regarding the use of this +function. +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_get 3 , +.Xr mac_prepare 3 , +.Xr mac_set 3 , +.Xr mac_text 3 , +.Xr mac 4 , +.Xr mac 9 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft +continues on the cross-platform POSIX.1e implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page +for more information. +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. +.Sh BUGS +POSIX.1e specifies that +.Fn mac_free +will be used to free text strings created using +.Xr mac_to_text 3 . +Because +.Vt mac_t +is a complex structure in the +.Tn TrustedBSD +implementation, +.Fn mac_free +is specific to that type, and must not be used to free the character +strings returned from +.Fn mac_to_text . +Doing so may result in undefined behavior, +including application failure. diff --git a/lib/libc/posix1e/mac_get.3 b/lib/libc/posix1e/mac_get.3 new file mode 100644 index 0000000..a83dfc9 --- /dev/null +++ b/lib/libc/posix1e/mac_get.3 @@ -0,0 +1,153 @@ +.\" Copyright (c) 2001, 2004 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and NAI Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS +.\" research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_get.3,v 1.10 2004/06/30 20:09:09 ru Exp $ +.\" +.Dd December 21, 2001 +.Dt MAC_GET 3 +.Os +.Sh NAME +.Nm mac_get_file , +.Nm mac_get_link , +.Nm mac_get_fd , +.Nm mac_get_peer , +.Nm mac_get_pid , +.Nm mac_get_proc +.Nd get the label of a file, socket, socket peer or process +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_get_file "const char *path" "mac_t label" +.Ft int +.Fn mac_get_link "const char *path" "mac_t label" +.Ft int +.Fn mac_get_fd "int fd" "mac_t label" +.Ft int +.Fn mac_get_peer "int fd" "mac_t label" +.Ft int +.Fn mac_get_pid "pid_t pid" "mac_t label" +.Ft int +.Fn mac_get_proc "mac_t label" +.Sh DESCRIPTION +The +.Fn mac_get_file +system call returns the label associated with a file specified by +pathname. +The +.Fn mac_get_link +function is the same as +.Fn mac_get_file , +except that it does not follow symlinks. +.Pp +The +.Fn mac_get_fd +system call returns the label associated with an object referenced by +the specified file descriptor. +Note that in the case of a file system socket, the label returned will +be the socket label, which may be different from the label of the +on-disk node acting as a rendezvous for the socket. +The +.Fn mac_get_peer +system call returns the label associated with the remote endpoint of +a socket; the exact semantics of this call will depend on the protocol +domain, communications type, and endpoint; typically this label will +be cached when a connection-oriented protocol instance is first set up, +and is undefined for datagram protocols. +.Pp +The +.Fn mac_get_pid +and +.Fn mac_get_proc +system calls return the process label associated with an arbitrary +process ID, or the current process. +.Pp +Label storage for use with these calls must first be allocated and +prepared using the +.Xr mac_prepare 3 +functions. +When an application is done using a label, the memory may be returned +using +.Xr mac_free 3 . +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EACCES +A component of +.Fa path +is not searchable, +or MAC read access to the file +is denied. +.It Bq Er EINVAL +The requested label operation is not valid for the object referenced by +.Fa fd . +.It Bq Er ENAMETOOLONG +The pathname pointed to by +.Fa path +exceeds +.Dv PATH_MAX , +or a component of the pathname exceeds +.Dv NAME_MAX . +.It Bq Er ENOENT +A component of +.Fa path +does not exist. +.It Bq Er ENOMEM +Insufficient memory is available +to allocate a new MAC label structure. +.It Bq Er ENOTDIR +A component of +.Fa path +is not a directory. +.El +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_free 3 , +.Xr mac_prepare 3 , +.Xr mac_set 3 , +.Xr mac_text 3 , +.Xr mac 4 , +.Xr mac 9 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft +continues on the cross-platform POSIX.1e implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page +for more information. +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. diff --git a/lib/libc/posix1e/mac_get.c b/lib/libc/posix1e/mac_get.c new file mode 100644 index 0000000..6babc79 --- /dev/null +++ b/lib/libc/posix1e/mac_get.c @@ -0,0 +1,86 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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. + * 3. The names of the authors may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_get.c,v 1.6 2008/03/07 15:25:56 rwatson Exp $ + */ + +#include +#include +#include + +extern int __mac_get_fd(int fd, struct mac *mac_p); +extern int __mac_get_file(const char *path_p, struct mac *mac_p); +extern int __mac_get_link(const char *path_p, struct mac *mac_p); +extern int __mac_get_pid(pid_t pid, struct mac *mac_p); +extern int __mac_get_proc(struct mac *mac_p); + +int +mac_get_fd(int fd, struct mac *label) +{ + + return (__mac_get_fd(fd, label)); +} + +int +mac_get_file(const char *path, struct mac *label) +{ + + return (__mac_get_file(path, label)); +} + +int +mac_get_link(const char *path, struct mac *label) +{ + + return (__mac_get_link(path, label)); +} + +int +mac_get_peer(int fd, struct mac *label) +{ + socklen_t len; + + len = sizeof(*label); + return (getsockopt(fd, SOL_SOCKET, SO_PEERLABEL, label, &len)); +} + +int +mac_get_pid(pid_t pid, struct mac *label) +{ + + return (__mac_get_pid(pid, label)); +} + +int +mac_get_proc(struct mac *label) +{ + + return (__mac_get_proc(label)); +} diff --git a/lib/libc/posix1e/mac_is_present.3 b/lib/libc/posix1e/mac_is_present.3 new file mode 100644 index 0000000..02a857c --- /dev/null +++ b/lib/libc/posix1e/mac_is_present.3 @@ -0,0 +1,89 @@ +.\" Copyright (c) 2002 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and NAI Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS +.\" research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_is_present.3,v 1.9 2006/09/30 10:29:43 ru Exp $ +.\" +.Dd July 7, 2006 +.Dt MAC_IS_PRESENT 3 +.Os +.Sh NAME +.Nm mac_is_present +.Nd report whether the running system has MAC support +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_is_present "const char *policyname" +.Sh DESCRIPTION +The +.Fn mac_is_present +function determines whether the currently-running kernel supports MAC for +a given policy or not. +If +.Fa policyname +is +.Pf non- Dv NULL , +the presence of the named policy +(e.g.\& +.Dq Li biba , +.Dq Li mls , +.Dq Li te ) +is checked, otherwise the presence of any MAC policies at all is checked. +.Sh RETURN VALUES +If the system supports the given MAC policy, the value 1 is returned. +If the specified MAC policy is not supported, the value 0 is returned. +If an error occurs, the value \-1 is returned. +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EINVAL +The value of +.Fa policyname +is not valid. +.It Bq Er ENOMEM +Insufficient memory was available to allocate internal storage. +.El +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_free 3 , +.Xr mac_get 3 , +.Xr mac_prepare 3 , +.Xr mac_set 3 , +.Xr mac_text 3 , +.Xr mac 4 , +.Xr mac 9 +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. diff --git a/lib/libc/posix1e/mac_prepare.3 b/lib/libc/posix1e/mac_prepare.3 new file mode 100644 index 0000000..2356da3 --- /dev/null +++ b/lib/libc/posix1e/mac_prepare.3 @@ -0,0 +1,134 @@ +.\" Copyright (c) 2002, 2003 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and Network Associates Labs, +.\" the Security Research Division of Network Associates, Inc. under +.\" DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the +.\" DARPA CHATS research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_prepare.3,v 1.8 2006/07/07 14:02:17 rwatson Exp $ +.\" +.Dd August 22, 2003 +.Os +.Dt MAC_PREPARE 3 +.Sh NAME +.Nm mac_prepare , mac_prepare_type , mac_prepare_file_label , +.Nm mac_prepare_ifnet_label , mac_prepare_process_label +.Nd allocate appropriate storage for +.Vt mac_t +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_prepare "mac_t *mac" "const char *elements" +.Ft int +.Fn mac_prepare_type "mac_t *mac" "const char *name" +.Ft int +.Fn mac_prepare_file_label "mac_t *mac" +.Ft int +.Fn mac_prepare_ifnet_label "mac_t *mac" +.Ft int +.Fn mac_prepare_process_label "mac_t *mac" +.Sh DESCRIPTION +The +.Nm +family of functions allocates the appropriate amount of storage and initializes +.Fa *mac +for use by +.Xr mac_get 3 . +When the resulting label is passed into the +.Xr mac_get 3 +functions, the kernel will attempt to fill in the label elements specified +when the label was prepared. +Elements are specified in a nul-terminated string, using commas to +delimit fields. +Element names may be prefixed with the +.Dv ? +character to indicate that a failure by the kernel to retrieve that +element should not be considered fatal. +.Pp +The +.Fn mac_prepare +function accepts a list of policy names as a parameter, and allocates the +storage to fit those label elements accordingly. +The remaining functions in the family make use of system defaults defined +in +.Xr mac.conf 5 +instead of an explicit +.Va elements +argument, deriving the default from the specified object type. +.Pp +.Fn mac_prepare_type +allocates the storage to fit an object label of the type specified by +the +.Va name +argument. +The +.Fn mac_prepare_file_label , +.Fn mac_prepare_ifnet_label , +and +.Fn mac_prepare_process_label +functions are equivalent to invocations of +.Fn mac_prepare_type +with arguments of +.Qq file , +.Qq ifnet , +and +.Qq process +respectively. +.Sh RETURN VALUES +Upon successful completion, a value of 0 is returned. +Otherwise, a value of \-1 is returned and +.Va errno +is set to indicate the error. +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_free 3 , +.Xr mac_get 3 , +.Xr mac_is_present 3 , +.Xr mac_set 3 , +.Xr mac 4 , +.Xr mac.conf 5 , +.Xr maclabel 7 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft +continues on the cross-platform POSIX.1e implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page +for more information. +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. +.Pp +Support for generic object types first appeared in +.Fx 5.2 . diff --git a/lib/libc/posix1e/mac_set.3 b/lib/libc/posix1e/mac_set.3 new file mode 100644 index 0000000..829faa4 --- /dev/null +++ b/lib/libc/posix1e/mac_set.3 @@ -0,0 +1,150 @@ +.\" Copyright (c) 2001 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and NAI Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS +.\" research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_set.3,v 1.11 2006/07/07 14:02:17 rwatson Exp $ +.\" +.Dd January 14, 2003 +.Dt MAC_SET 3 +.Os +.Sh NAME +.Nm mac_set_file , +.Nm mac_set_fd , +.Nm mac_set_proc +.Nd set the MAC label for a file or process +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_set_file "const char *path" "mac_t label" +.Ft int +.Fn mac_set_link "const char *path" "mac_t label" +.Ft int +.Fn mac_set_fd "int fd" "mac_t label" +.Ft int +.Fn mac_set_proc "mac_t label" +.Sh DESCRIPTION +The +.Fn mac_set_file +and +.Fn mac_set_fd +functions associate a MAC label +specified by +.Fa label +to the file referenced to by +.Fa path_p , +or to the file descriptor +.Fa fd , +respectively. +Note that when a file descriptor references a socket, label operations +on the file descriptor act on the socket, not on the file that may +have been used as a rendezvous when binding the socket. +The +.Fn mac_set_link +function is the same as +.Fn mac_set_file , +except that it does not follow symlinks. +.Pp +The +.Fn mac_set_proc +function associates the MAC label +specified by +.Fa label +to the calling process. +.Pp +A process is allowed to set a label for a file +only if it has MAC write access to the file, +and its effective user ID is equal to +the owner of the file, +or has appropriate privileges. +.Sh RETURN VALUES +.Rv -std mac_set_fd mac_set_file mac_set_link mac_set_proc +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EACCES +MAC write access to the file is denied. +.It Bq Er EBADF +The +.Fa fd +argument +is not a valid file descriptor. +.It Bq Er EINVAL +The +.Fa label +argument +is not a valid MAC label, or the object referenced by +.Fa fd +is not appropriate for label operations. +.It Bq Er EOPNOTSUPP +Setting MAC labels is not supported +by the file referenced by +.Fa fd . +.It Bq Er EPERM +The calling process had insufficient privilege +to change the MAC label. +.It Bq Er EROFS +File system for the object being modified +is read only. +.It Bq Er ENAMETOOLONG +.\" XXX POSIX_NO_TRUNC? +The length of the pathname in +.Fa path_p +exceeds +.Dv PATH_MAX , +or a component of the pathname +is longer than +.Dv NAME_MAX . +.It Bq Er ENOENT +The file referenced by +.Fa path_p +does not exist. +.It Bq Er ENOTDIR +A component of the pathname +referenced by +.Fa path_p +is not a directory. +.El +.Sh SEE ALSO +.Xr mac 3 , +.Xr mac_free 3 , +.Xr mac_get 3 , +.Xr mac_is_present 3 , +.Xr mac_prepare 3 , +.Xr mac_text 3 , +.Xr mac 4 , +.Xr mac 9 +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. diff --git a/lib/libc/posix1e/mac_set.c b/lib/libc/posix1e/mac_set.c new file mode 100644 index 0000000..f059f3a --- /dev/null +++ b/lib/libc/posix1e/mac_set.c @@ -0,0 +1,68 @@ +/* + * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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. + * 3. The names of the authors may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_set.c,v 1.4 2008/03/07 15:25:56 rwatson Exp $ + */ + +#include +#include + +extern int __mac_set_fd(int fd, struct mac *mac_p); +extern int __mac_set_file(const char *path_p, struct mac *mac_p); +extern int __mac_set_link(const char *path_p, struct mac *mac_p); +extern int __mac_set_proc(struct mac *mac_p); + +int +mac_set_fd(int fd, struct mac *label) +{ + + return (__mac_set_fd(fd, label)); +} + +int +mac_set_file(const char *path, struct mac *label) +{ + + return (__mac_set_file(path, label)); +} + +int +mac_set_link(const char *path, struct mac *label) +{ + + return (__mac_set_link(path, label)); +} + +int +mac_set_proc(struct mac *label) +{ + + return (__mac_set_proc(label)); +} diff --git a/lib/libc/posix1e/mac_text.3 b/lib/libc/posix1e/mac_text.3 new file mode 100644 index 0000000..6e78b43 --- /dev/null +++ b/lib/libc/posix1e/mac_text.3 @@ -0,0 +1,118 @@ +.\" Copyright (c) 2001 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris +.\" Costello at Safeport Network Services and NAI Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS +.\" research program. +.\" +.\" 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 AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: mac_text.3,v 1.12 2006/07/07 14:02:17 rwatson Exp $ +.\" +.Dd December 21, 2001 +.Dt MAC_TEXT 3 +.Os +.Sh NAME +.Nm mac_from_text , +.Nm mac_to_text +.Nd convert MAC label to/from text representation +.Sh SYNOPSIS +.In sys/mac.h +.Ft int +.Fn mac_from_text "mac_t *mac" "const char *text" +.Ft int +.Fn mac_to_text "mac_t label" "char **text" +.Sh DESCRIPTION +The +.Fn mac_from_text +function converts the text representation of a label +into the internal policy label format +.Pq Vt mac_t +and places it in +.Fa *mac , +which must later be freed with +.Xr free 3 . +.Pp +The +.Fn mac_to_text +function allocates storage for +.Fa *text , +which will be set to the text representation of +.Fa label . +.Pp +Refer to +.Xr maclabel 7 +for the MAC label format. +.Sh RETURN VALUES +.Rv -std mac_from_text mac_to_text +.Sh COMPATIBILITY +POSIX.1e does not define +a format for text representations +of MAC labels. +.Pp +POSIX.1e requires that text strings allocated using +.Fn mac_to_text +be freed using +.Xr mac_free 3 ; +in the +.Fx +implementation, they must be freed using +.Xr free 3 , +as +.Xr mac_free 3 +is used only to free memory used for type +.Vt mac_t . +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er ENOMEM +Insufficient memory was available +to allocate internal storage. +.El +.Sh SEE ALSO +.Xr free 3 , +.Xr mac 3 , +.Xr mac_get 3 , +.Xr mac_is_present 3 , +.Xr mac_prepare 3 , +.Xr mac_set 3 , +.Xr mac 4 , +.Xr maclabel 7 +.Sh STANDARDS +POSIX.1e is described in IEEE POSIX.1e draft 17. +Discussion of the draft +continues on the cross-platform POSIX.1e implementation mailing list. +To join this list, see the +.Fx +POSIX.1e implementation page +for more information. +.Sh HISTORY +Support for Mandatory Access Control was introduced in +.Fx 5.0 +as part of the +.Tn TrustedBSD +Project, and later ported to +.Ox +as part of the +.Tn ANOUBIS +Project. diff --git a/lib/libc/sys/Makefile.inc b/lib/libc/sys/Makefile.inc index 8b7248a..14e4839 100644 --- a/lib/libc/sys/Makefile.inc +++ b/lib/libc/sys/Makefile.inc @@ -65,6 +65,24 @@ ASM= accept.o access.o acct.o adjfreq.o adjtime.o bind.o chdir.o chflags.o \ __syscall.o __sysctl.o __getcwd.o sched_yield.o getthrid.o \ thrsleep.o thrwakeup.o threxit.o thrsigdivert.o +# ACL system calls. +ASM+= __acl_get_file.o __acl_set_file.o __acl_get_fd.o __acl_set_fd.o \ + __acl_delete_file.o __acl_delete_fd.o __acl_aclcheck_file.o \ + __acl_aclcheck_fd.o __acl_get_link.o __acl_set_link.o \ + __acl_delete_link.o __acl_aclcheck_link.o + +# Extended attributes system calls. +ASM+= extattr_set_fd.o extattr_get_fd.o extattr_delete_fd.o \ + extattr_set_link.o extattr_get_link.o extattr_delete_link.o \ + extattr_list_fd.o extattr_list_file.o extattr_list_link.o \ + extattrctl.o extattr_set_file.o extattr_get_file.o \ + extattr_delete_file.o + +# MAC system calls. +ASM+= __mac_get_pid.o __mac_get_proc.o __mac_set_proc.o __mac_get_fd.o \ + __mac_get_file.o __mac_get_link.o __mac_set_fd.o __mac_set_file.o \ + __mac_set_link.o mac_syscall.o + GASM= ${ASM:.o=.go} PASM= ${ASM:.o=.po} SASM= ${ASM:.o=.so} @@ -212,7 +230,7 @@ LintSysPseudoNoerr.c: ${LIBCSRCDIR}/sys/makelintstub.sh \ MAN+= accept.2 access.2 acct.2 adjfreq.2 adjtime.2 bind.2 brk.2 chdir.2 \ chflags.2 \ chmod.2 chown.2 chroot.2 clock_gettime.2 close.2 closefrom.2 connect.2 \ - dup.2 execve.2 _exit.2 fcntl.2 fhopen.2 \ + dup.2 execve.2 _exit.2 extattr_get_file.2 fcntl.2 fhopen.2 \ flock.2 fork.2 fsync.2 getdirentries.2 \ getfh.2 getfsstat.2 getgid.2 getgroups.2 getitimer.2 getlogin.2 \ getpeername.2 getpeereid.2 getpgrp.2 \ @@ -244,6 +262,18 @@ MLINKS+=chown.2 lchown.2 MLINKS+=clock_gettime.2 clock_settime.2 MLINKS+=clock_gettime.2 clock_getres.2 MLINKS+=execve.2 exect.2 +MLINKS+=extattr_get_file.2 extattr.2 \ + extattr_get_file.2 extattr_delete_fd.2 \ + extattr_get_file.2 extattr_delete_file.2 \ + extattr_get_file.2 extattr_delete_list.2 \ + extattr_get_file.2 extattr_get_fd.2 \ + extattr_get_file.2 extattr_get_list.2 \ + extattr_get_file.2 extattr_list_fd.2 \ + extattr_get_file.2 extattr_list_file.2 \ + extattr_get_file.2 extattr_list_link.2 \ + extattr_get_file.2 extattr_set_fd.2 \ + extattr_get_file.2 extattr_set_file.2 \ + extattr_get_file.2 extattr_set_link.2 MLINKS+=fhopen.2 fhstat.2 fhopen.2 fhstatfs.2 MLINKS+=getgid.2 getegid.2 MLINKS+=getitimer.2 setitimer.2 diff --git a/lib/libc/sys/extattr_get_file.2 b/lib/libc/sys/extattr_get_file.2 new file mode 100644 index 0000000..650cd21 --- /dev/null +++ b/lib/libc/sys/extattr_get_file.2 @@ -0,0 +1,280 @@ +.\" +.\" Copyright (c) 2008 GeNUA mbH +.\" Copyright (c) 2003 Robert Watson +.\" Copyright (c) 2001 Dima Dorfman +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: extattr_get_file.2,v 1.19 2008/01/29 18:15:38 trhodes Exp $ +.\" +.Dd January 29, 2008 +.Dt EXTATTR 2 +.Os +.Sh NAME +.Nm extattr_get_fd , +.Nm extattr_set_fd , +.Nm extattr_delete_fd , +.Nm extattr_list_fd , +.Nm extattr_get_file , +.Nm extattr_set_file , +.Nm extattr_delete_file , +.Nm extattr_list_file , +.Nm extattr_get_link , +.Nm extattr_set_link , +.Nm extattr_delete_link , +.Nm extattr_list_link +.Nd system calls to manipulate extended attributes +.Sh SYNOPSIS +.In sys/types.h +.In sys/extattr.h +.Ft ssize_t +.Fn extattr_get_fd "int fd" "int attrnamespace" "const char *attrname" "void *data" "size_t nbytes" +.Ft int +.Fn extattr_set_fd "int fd" "int attrnamespace" "const char *attrname" "const void *data" "size_t nbytes" +.Ft int +.Fn extattr_delete_fd "int fd" "int attrnamespace" "const char *attrname" +.Ft ssize_t +.Fn extattr_list_fd "int fd" "int attrnamespace" "void *data" "size_t nbytes" +.Ft ssize_t +.Fn extattr_get_file "const char *path" "int attrnamespace" "const char *attrname" "void *data" "size_t nbytes" +.Ft int +.Fn extattr_set_file "const char *path" "int attrnamespace" "const char *attrname" "const void *data" "size_t nbytes" +.Ft int +.Fn extattr_delete_file "const char *path" "int attrnamespace" "const char *attrname" +.Ft ssize_t +.Fn extattr_list_file "const char *path" "int attrnamespace" "void *data" "size_t nbytes" +.Ft ssize_t +.Fn extattr_get_link "const char *path" "int attrnamespace" "const char *attrname" "void *data" "size_t nbytes" +.Ft int +.Fn extattr_set_link "const char *path" "int attrnamespace" "const char *attrname" "const void *data" "size_t nbytes" +.Ft int +.Fn extattr_delete_link "const char *path" "int attrnamespace" "const char *attrname" +.Ft ssize_t +.Fn extattr_list_link "const char *path" "int attrnamespace" "void *data" "size_t nbytes" +.Sh DESCRIPTION +Extended attributes are userland-manipulable metadata associated with file +system objects. +They exist as +.Qq Li name, value +pairs within a set of namespaces. +.Pp +The +.Fn extattr_get_file +system call retrieves the value of the specified extended attribute into +a buffer of +.Fa nbytes +bytes pointed to by +.Fa data . +.Pp +The +.Fn extattr_set_file +system call sets the value of the specified extended attribute to the data +contained in +.Fa data . +.Pp +The +.Fn extattr_delete_file +system call deletes the specified extended attribute. +.Pp +The +.Fn extattr_list_file +returns a list of attributes present in the requested namespace. +Each entry consists of a single byte containing the length +of the attribute name, followed by the attribute name. +Note that the attribute name is not terminated by ASCII 0 (nul). +.Pp +The +.Fn extattr_get_file , +and +.Fn extattr_list_file +calls consume the +.Fa data +and +.Fa nbytes +arguments in the same way as +.Xr read 2 , +while +.Fn extattr_set_file +consumes these arguments in the same way as +.Xr write 2 . +.Pp +If +.Fa data +is +.Dv NULL +in a call to +.Fn extattr_get_file +and +.Fn extattr_list_file +then the size of defined extended attribute data will be returned, rather +than the quantity read, permitting applications to test the size of the +data without performing a read. +The +.Fn extattr_delete_link , +.Fn extattr_get_link , +and +.Fn extattr_set_link +system calls behave in the same way as their _file counterparts, except that +they do not follow symlinks. +.Pp +The +.Fn extattr_get_fd , +.Fn extattr_set_fd , +.Fn extattr_delete_fd , +and +.Fn extattr_list_fd , +calls are identical to their +.Qq Li _file +counterparts except for the first argument. +The +.Qq Li _fd +functions take a file descriptor, while the +.Qq Li _file +functions take a path. +Both arguments describe a file system object associated with the extended +attribute that should be manipulated. +.Pp +The following arguments are common to all the system calls described in this +document: +.Bl -tag -width attrnamespace +.It Fa attrnamespace +the namespace in which the extended attribute resides. See +.Xr extattr 9 +and +.Xr extattr_namespace_to_string 2 . +.It Fa attrname +the name of the extended attribute +.El +.Pp +Named extended attribute semantics vary according to the underlying file +system. +Not all operations may be supported for a particular attribute. +Additionally, the format of the data in +.Fa data +can be attribute-specific. +.Sh RETURN VALUES +If successful, the +.Fn extattr_get_file , +.Fn extattr_set_file , +and +.Fn extattr_list_file +calls return the number of bytes +that were read from or written to +.Fa data , +respectively, or if +.Fa data +was +.Dv NULL , +then +.Fn extattr_get_file +and +.Fn extattr_list_file +return the number of bytes available to read. +If any of the calls are unsuccessful, \-1 is returned +and the global variable +.Va errno +is set to indicate the error. +.Pp +.Rv -std extattr_delete_file +.Sh ERRORS +Errors emerging from file system specific routines are not restricted to any +particular subset, and can be anything. The errors returned by FFS2 are: +.Bl -tag -width Er +.It Bq Er EIO +An I/O error occurred while reading from or writing to the file system. +.It Bq EINVAL +Attribute name and content must be at least one byte long. +.It Bq EINVAL +Corrupted extended attribute entry. +.It Bq Er ENOMEM +Could not allocate memory to describe inode's extended attribute area. +.It Bq ENOSPC +The file system is out of space. +.It Bq Er EOPNOTSUPP +The file system object being referenced is not a file, a directory or a +symbolic link. +.It Bq Er EPERM +Insufficient credentials. See +.Xr extattr 9 +for details. +.It Bq Er EROFS +Write operation attempted on read-only file system. +.El +.Pp +There is also a subset of errors returned directly by the system calls, and +these include: +.Bl -tag -width Er +.It Bq Er EFAULT +The +.Fa attrnamespace +and +.Fa attrname +arguments, +or the memory range defined by +.Fa data +and +.Fa nbytes +point outside the process's allocated address space. +.It Bq Er ENAMETOOLONG +The attribute name was longer than +.Dv EXTATTR_MAXNAMELEN . +.El +.Pp +The +.Fn extattr_get_fd , +.Fn extattr_set_fd , +.Fn extattr_delete_fd , +and +.Fn extattr_list_fd +system calls may also fail with: +.Bl -tag -width Er +.It Bq Er EBADF +The file descriptor referenced by +.Fa fd +was invalid. +.El +.Pp +Additionally, the +.Fn extattr_get_file , +.Fn extattr_set_file , +and +.Fn extattr_delete_file +calls may also fail due to the following errors: +.Bl -tag -width Er +.It Bq Er ENOATTR +The requested attribute was not defined for this file. +.It Bq Er ENOTDIR +A component of the path prefix is not a directory. +.It Bq Er ENAMETOOLONG +A component of a pathname exceeded 255 characters, +or an entire path name exceeded 1023 characters. +.It Bq Er ENOENT +A component of the path name that must exist does not exist. +.It Bq Er EACCES +Search permission is denied for a component of the path prefix. +.El +.Sh SEE ALSO +.Xr extattr 3 , +.Xr getextattr 8 , +.Xr setextattr 8 , +.Xr extattr 9 diff --git a/regress/lib/libc/posix1e/Makefile b/regress/lib/libc/posix1e/Makefile new file mode 100644 index 0000000..60ea311 --- /dev/null +++ b/regress/lib/libc/posix1e/Makefile @@ -0,0 +1,3 @@ +SUBDIR= extattr_namespaces + +.include diff --git a/regress/lib/libc/posix1e/extattr_namespaces/Makefile b/regress/lib/libc/posix1e/extattr_namespaces/Makefile new file mode 100644 index 0000000..a61a37c --- /dev/null +++ b/regress/lib/libc/posix1e/extattr_namespaces/Makefile @@ -0,0 +1,3 @@ +PROG= extattr_namespaces + +.include diff --git a/regress/lib/libc/posix1e/extattr_namespaces/extattr_namespaces.c b/regress/lib/libc/posix1e/extattr_namespaces/extattr_namespaces.c new file mode 100644 index 0000000..80a6600 --- /dev/null +++ b/regress/lib/libc/posix1e/extattr_namespaces/extattr_namespaces.c @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include + +#include +#include + +/* + * Check that extattr_namespace_to_string() and extattr_string_to_namespace() + * know at least about EXTATTR_NAMESPACE_USER and EXTATTR_NAMESPACE_SYSTEM. + */ +int +main(void) +{ + int attrnamespace; + char *str; + + if (extattr_namespace_to_string(EXTATTR_NAMESPACE_USER, &str) < 0) + err(1, "extattr_namespace_to_string 1"); + + if (extattr_string_to_namespace(str, &attrnamespace) < 0) + err(1, "extattr_string_to_namespace 1"); + + if (attrnamespace != EXTATTR_NAMESPACE_USER) + errx(1, "namespace mismatch 1"); + + free(str); + + if (extattr_namespace_to_string(EXTATTR_NAMESPACE_SYSTEM, &str) < 0) + err(1, "extattr_namespace_to_string 2"); + + if (extattr_string_to_namespace(str, &attrnamespace) < 0) + err(1, "extattr_string_to_namespace 2"); + + if (attrnamespace != EXTATTR_NAMESPACE_SYSTEM) + errx(1, "namespace mismatch 2"); + + free(str); + + exit(0); +} diff --git a/regress/sys/ffs2/Makefile b/regress/sys/ffs2/Makefile new file mode 100644 index 0000000..ac61e2f --- /dev/null +++ b/regress/sys/ffs2/Makefile @@ -0,0 +1,3 @@ +SUBDIR= acl extattr + +.include diff --git a/regress/sys/ffs2/acl/Makefile b/regress/sys/ffs2/acl/Makefile new file mode 100644 index 0000000..38ecd28 --- /dev/null +++ b/regress/sys/ffs2/acl/Makefile @@ -0,0 +1,23 @@ +FSIZE?= 2048 +BSIZE?= 16384 +COUNT?= 128 +VND?= vnd0 + +mount: + sh ${.CURDIR}/setup.sh + dd if=/dev/zero of=${.CURDIR}/fakedisk bs=${BSIZE} count=${COUNT} + mkdir ${.CURDIR}/fakemount + vnconfig s${VND} ${.CURDIR}/fakedisk + newfs -f ${FSIZE} -b ${BSIZE} -O 2 /dev/rs${VND}c + tunefs -a set /dev/rs${VND}c + mount /dev/s${VND}c ${.CURDIR}/fakemount + +unmount: + -umount ${.CURDIR}/fakemount + -vnconfig -u s${VND} + -rm -rf ${.CURDIR}/fakedisk ${.CURDIR}/fakemount + sh ${.CURDIR}/cleanup.sh + +SUBDIR= acl_groupdir acl_groupfile acl_userdir acl_userfile + +.include diff --git a/regress/sys/ffs2/acl/README b/regress/sys/ffs2/acl/README new file mode 100644 index 0000000..063cd62 --- /dev/null +++ b/regress/sys/ffs2/acl/README @@ -0,0 +1,14 @@ +While most of these tests are not implementation-specific per se, they are here +because FFS2 is the only file system to support access control lists in OpenBSD. +In order to perform them, it is necessary: + +(1) To have superuser privileges. +(2) To be running a kernel compiled with options 'FFS2', 'ACL' and 'EXTATTR'. +(3) To have a vacant vnd(4) slot represented in 'VND' (an environment variable). +(4) To have spare '_beta0', '_beta1', '_gamma0' and '_gamma1' groupnames. +(5) To have spare '_alpha0', '_alpha1', '_alpha2' and '_alpha3' usernames. + +If not set, 'VND' is assumed as 'vnd0'. + +A summary of what each test does can be found in the respective '.sh' file, +in a comment just after the license. diff --git a/regress/sys/ffs2/acl/acl_groupdir/Makefile b/regress/sys/ffs2/acl/acl_groupdir/Makefile new file mode 100644 index 0000000..fb9d47a --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupdir/Makefile @@ -0,0 +1,18 @@ +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress: + sh ${.CURDIR}/acl_groupdir.sh ${TMPDIR} |\ + diff -u - ${.CURDIR}/acl_groupdir.out + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPDIR=`mktemp -d ${FAKEMNT}/acl.XXXXXXXX` run-regress) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.out b/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.out new file mode 100644 index 0000000..abedaac --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.out @@ -0,0 +1,786 @@ +Starting tests... +acl_groupdir(_alpha0, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, rw) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, rx) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, rwx) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, w) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, w) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, wx) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, r, x) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, r, x) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, r, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, r, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, rw) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, rx) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, rwx) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, w) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, w) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, wx) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, r, x) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, r, x) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, r, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, r, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, rx) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, rwx) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, wx) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rw, x) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rw, x) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rw, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rw, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, rx) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, rwx) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, wx) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rw, x) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rw, x) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rw, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rw, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, rw) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, rwx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, w) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, wx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, rw) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, rwx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, w) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, wx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, rwx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, rwx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, rwx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, rwx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, r) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, r) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, rw) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, rx) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, rwx) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, w, x) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, w, x) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma0, w, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, w, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, r) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, r) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, rw) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, rx) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, rwx) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, w, x) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta0, _gamma1, w, x) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, w, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, w, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, r) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, rw) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, rx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, rwx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, wx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, wx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, r) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, rw) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, rx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, rwx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, wx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, wx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, r) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, r) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, r) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, rw) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, rx) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, rwx) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, w) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, w) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, w) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, wx) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta0, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, r) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, r) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, r) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, rw) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, rx) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, rwx) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, w) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, w) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, w) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, wx) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta0, _gamma1, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta0, _gamma1, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta0, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupdir(_alpha3, _beta0, _gamma1, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, rw) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, rx) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, rwx) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, w) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, w) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, wx) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, r, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, r, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, r, x) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, r, x) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, rw) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, rx) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, rwx) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, w) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, w) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, wx) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, r, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, r, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, r, x) -> (0, 1, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, r, x) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, rx) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, rwx) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, wx) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rw, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rw, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rw, x) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rw, x) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, rx) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, rwx) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, wx) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rw, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rw, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rw, x) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rw, x) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, rw) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, rwx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, w) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, wx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, rw) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, rwx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, w) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, wx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, rwx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, rwx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, rwx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, rwx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, r) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, r) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, rw) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, rx) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, rwx) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma0, w, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, w, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, w, x) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, w, x) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, r) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, r) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, rw) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, rx) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, rwx) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, w, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, w, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, w, x) -> (1, 0, 1) OK +acl_groupdir(_alpha3, _beta1, _gamma1, w, x) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, r) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, rw) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, rx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, rwx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, wx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, wx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, r) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, r) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, rw) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, rx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, rx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, rwx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, w) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, wx, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, wx, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, wx, x) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, r) -> (0, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, r) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, r) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, r) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, rw) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, rx) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, rwx) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, w) -> (1, 0, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, w) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, w) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, w) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, wx) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha1, _beta1, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma0, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, r) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, r) -> (0, 1, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, r) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, r) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, rw) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, rw) -> (0, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, rw) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, rw) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, rx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, rx) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, rwx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, rwx) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, w) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, w) -> (1, 0, 1) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, w) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, w) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, wx) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, wx) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, wx) -> (1, 0, 0) OK +acl_groupdir(_alpha0, _beta1, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupdir(_alpha1, _beta1, _gamma1, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha2, _beta1, _gamma1, x, x) -> (1, 1, 0) OK +acl_groupdir(_alpha3, _beta1, _gamma1, x, x) -> (1, 1, 0) OK +784 tests run, 0 failed diff --git a/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.sh b/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.sh new file mode 100644 index 0000000..750f684 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupdir/acl_groupdir.sh @@ -0,0 +1,161 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This test asserts that permissions are correctly enforced when members of +# two distinct groups (composed of two users each) try to access a directory. +# For every +# combination possible, the followings steps are performed: +# +# (1) Try to inspect the contents of a directory (requires *READ* access). +# (2) Change the working directory (requires *EXEC* access in destination). +# (3) Move a directory (requires *WRITE* access). +# +# All tests are checked for success and failure when expected, in a total of +# 4 (users) * 2^2 (groups) * 7^2 (permissions) = 784 individual tests. + +ALPHA="0 1 2 3" +BETA="0 1" +GAMMA="0 1" +MODES="r rw rx rwx w wx x" +RUN=0 +FAILED=0 + +assert() { + local beta=`expr $2 / 2` + local gamma=`expr $2 % 2` + local result="OK" + + if [ $7 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *r*) + ;; + *) + echo "Inappropriate read access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *r*) + echo "Inappropriate read access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + if [ $8 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *w*) + ;; + *) + echo "Inappropriate write access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *w*) + echo "Inappropriate write access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + if [ $9 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *x*) + ;; + *) + echo "Inappropriate execution access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *x*) + echo "Inappropriate execution access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + echo "$1(_alpha$2, _beta$3, _gamma$4, $5, $6) -> ($7, $8, $9) $result" + if [ $result = "FAILED" ]; then + FAILED=`expr $FAILED + 1` + fi +} + +test() { + local dir1=`mktemp -d -p $WRKDIR` + local dir2=`mktemp -d -p $WRKDIR` + local r w x + + chown _alpha$1 $WRKDIR $dir2 + setfacl -m g:_beta$2:$4,g:_gamma$3:$5 $dir1 + + sudo -u _alpha$1 ls $dir1 2>/dev/null + r=$? + sudo -u _alpha$1 sh -c "cd $dir1" 2>/dev/null + x=$? + # Note: There is a difference in behaviour between OpenBSD and Linux + # regarding the renaming of directories. Linux does *not* require + # write permission if the directory is being moved within a given + # 'parent' directory, while OpenBSD does. + sudo -u _alpha$1 mv $dir1 $dir2 2>/dev/null + w=$? + + assert acl_groupdir $1 $2 $3 $4 $5 $r $w $x + rm -rf $dir1 $dir2 + RUN=`expr $RUN + 1` +} + +if [ -z $1 ]; then + echo "Please specify a work directory as a first argument." + exit 1 +fi + +WRKDIR=$1 +echo Starting tests... + +for beta in $BETA; do + for mode in $MODES; do + permb[$beta]=$mode + for gamma in $GAMMA; do + for mode in $MODES; do + permg[$gamma]=$mode + for alpha in $ALPHA; do + test $alpha $beta $gamma \ + ${permb[$beta]} ${permg[$gamma]} + done + done + permg[$gamma]="" + done + done + permb[$beta]="" +done + +echo $RUN tests run, $FAILED failed diff --git a/regress/sys/ffs2/acl/acl_groupfile/Makefile b/regress/sys/ffs2/acl/acl_groupfile/Makefile new file mode 100644 index 0000000..b181cf9 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupfile/Makefile @@ -0,0 +1,17 @@ +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress: + sh ${.CURDIR}/acl_groupfile.sh ${FAKEMNT} |\ + diff -u - ${.CURDIR}/acl_groupfile.out + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && exec ${MAKE} run-regress) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.out b/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.out new file mode 100644 index 0000000..7c1d877 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.out @@ -0,0 +1,786 @@ +Starting tests... +acl_groupfile(_alpha0, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, r) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, rw) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, rx) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, rwx) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, w) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, w) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, w) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, wx) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, r, x) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, r, x) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, r, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, r, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, r) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, rw) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, rx) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, rwx) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, w) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, w) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, w) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, wx) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, r, x) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, r, x) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, r, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, r, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, r) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, r) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, rx) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, rwx) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, w) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, wx) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rw, x) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rw, x) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rw, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rw, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, r) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, r) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, rx) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, rwx) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, w) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, wx) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rw, x) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rw, x) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rw, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rw, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, rw) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, rwx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, w) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, wx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, rw) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, rwx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, w) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, wx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma0, rwx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, rwx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, rwx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, rwx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, r) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, r) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, r) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, r) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, rx) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, rwx) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, w) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, wx) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, w, x) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, w, x) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta0, _gamma0, w, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, w, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, r) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, r) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, r) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, r) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, rx) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, rwx) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, w) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, wx) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, w, x) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta0, _gamma1, w, x) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, w, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, w, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, r) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, rx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, rwx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, wx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, wx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, r) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, rx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, rwx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, wx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, wx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, r) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, r) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, r) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, r) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, rx) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, rwx) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, w) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, w) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, w) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, wx) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta0, _gamma0, x, x) -> (1, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, r) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, r) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, r) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, r) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, rx) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, rwx) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, w) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, w) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, w) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, wx) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta0, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta0, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta0, _gamma1, x, x) -> (1, 1, 127) OK +acl_groupfile(_alpha3, _beta0, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, r) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, rw) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, rx) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, rwx) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, w) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, w) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, w) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, wx) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, r, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, r, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, r, x) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, r, x) -> (0, 1, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, r) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, r) -> (0, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, rw) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, rx) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, rwx) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, w) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, w) -> (0, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, w) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, wx) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, r, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, r, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, r, x) -> (0, 1, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, r, x) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, r) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, r) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, rx) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, rwx) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, w) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, wx) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rw, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rw, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rw, x) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rw, x) -> (0, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, r) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, r) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, r) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, rx) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, rwx) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, w) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, w) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, wx) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rw, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rw, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rw, x) -> (0, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rw, x) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, rw) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, rwx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, w) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, wx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, r) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, rw) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, rwx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, w) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, wx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rx, x) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, rwx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, rwx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, w) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, wx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, rwx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, rwx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma1, rwx, x) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, r) -> (0, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, r) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, r) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, r) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, rx) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, rwx) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, w) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, wx) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma0, w, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, w, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, w, x) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, w, x) -> (1, 0, 127) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, r) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, r) -> (0, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, r) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, r) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, rw) -> (0, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, rx) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, rwx) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, w) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, wx) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, w, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, w, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, w, x) -> (1, 0, 127) OK +acl_groupfile(_alpha3, _beta1, _gamma1, w, x) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, r) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, rx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, rwx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, wx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, wx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, r) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, r) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, r) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, r) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, rw) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, rx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, rx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, rwx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, w) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, w) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, wx, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, wx, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, wx, x) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, r) -> (0, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, r) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, r) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, r) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, rx) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, rwx) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, w) -> (1, 0, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, w) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, w) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, w) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, wx) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha1, _beta1, _gamma0, x, x) -> (1, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma0, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, r) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, r) -> (0, 1, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, r) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, r) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, rw) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, rw) -> (0, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, rw) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, rw) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, rx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, rx) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, rx) -> (0, 1, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, rwx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, rwx) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, rwx) -> (0, 0, 0) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, w) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, w) -> (1, 0, 127) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, w) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, w) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, wx) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, wx) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, wx) -> (1, 0, 1) OK +acl_groupfile(_alpha0, _beta1, _gamma1, x, x) -> (1, 1, 127) OK +acl_groupfile(_alpha1, _beta1, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha2, _beta1, _gamma1, x, x) -> (1, 1, 1) OK +acl_groupfile(_alpha3, _beta1, _gamma1, x, x) -> (1, 1, 1) OK +784 tests run, 0 failed diff --git a/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.sh b/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.sh new file mode 100644 index 0000000..457059c --- /dev/null +++ b/regress/sys/ffs2/acl/acl_groupfile/acl_groupfile.sh @@ -0,0 +1,159 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This test asserts that permissions are correctly enforced when members of +# two distinct groups (composed of two users each) try to access a file. +# For every +# combination possible, the followings steps are performed: +# +# (1) Try to read from the file. +# (2) Try to execute the file. +# (3) Try to write to the file. +# +# All tests are checked for success and failure when expected, in a total of +# 4 (users) * 2^2 (groups) * 7^2 (permissions) = 784 individual tests. + +ALPHA="0 1 2 3" +BETA="0 1" +GAMMA="0 1" +MODES="r rw rx rwx w wx x" +RUN=0 +FAILED=0 + +assert() { + local beta=`expr $2 / 2` + local gamma=`expr $2 % 2` + local result="OK" + + if [ $7 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *r*) + ;; + *) + echo "Inappropriate read access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *r*) + echo "Inappropriate read access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + if [ $8 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *w*) + ;; + *) + echo "Inappropriate write access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *w*) + echo "Inappropriate write access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + if [ $9 -eq 0 ]; then + case ${permb[$beta]}${permg[$gamma]} in + *x*r*) + ;; + *r*x*) + ;; + *) + echo "Inappropriate execution access granted!" + result="FAILED" + ;; + esac + else + case ${permb[$beta]}${permg[$gamma]} in + *x*r*) + ;; + *r*x*) + echo "Inappropriate execution access denial!" + result="FAILED" + ;; + *) + ;; + esac + fi + echo "$1(_alpha$2, _beta$3, _gamma$4, $5, $6) -> ($7, $8, $9) $result" + if [ $result = "FAILED" ]; then + FAILED=`expr $FAILED + 1` + fi +} + +test() { + local file=`mktemp -p $WRKDIR` + local r w x + + setfacl -m g:_beta$2:$4,g:_gamma$3:$5 $file + + sudo -u _alpha$1 cat $file 2>/dev/null + r=$? + sudo -u _alpha$1 $file 2>/dev/null + x=$? + sudo -u _alpha$1 sh -c "echo 1 > $file" 2>/dev/null + w=$? + + assert acl_groupfile $1 $2 $3 $4 $5 $r $w $x + rm -rf $file + RUN=`expr $RUN + 1` +} + +if [ -z $1 ]; then + echo "Please specify a work directory as a first argument." + exit 1 +fi + +WRKDIR=$1 +echo Starting tests... + +for beta in $BETA; do + for mode in $MODES; do + permb[$beta]=$mode + for gamma in $GAMMA; do + for mode in $MODES; do + permg[$gamma]=$mode + for alpha in $ALPHA; do + test $alpha $beta $gamma \ + ${permb[$beta]} ${permg[$gamma]} + done + done + permg[$gamma]="" + done + done + permb[$beta]="" +done + +echo $RUN tests run, $FAILED failed diff --git a/regress/sys/ffs2/acl/acl_userdir/Makefile b/regress/sys/ffs2/acl/acl_userdir/Makefile new file mode 100644 index 0000000..f8ebe62 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userdir/Makefile @@ -0,0 +1,18 @@ +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress: + sh ${.CURDIR}/acl_userdir.sh ${TMPDIR} |\ + diff -u - ${.CURDIR}/acl_userdir.out + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPDIR=`mktemp -d ${FAKEMNT}/acl.XXXXXXXX` run-regress) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/acl/acl_userdir/acl_userdir.out b/regress/sys/ffs2/acl/acl_userdir/acl_userdir.out new file mode 100644 index 0000000..453bbf3 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userdir/acl_userdir.out @@ -0,0 +1,9606 @@ +Starting tests... +acl_userdir(_alpha0, r, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, r, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rw, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rw, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rw, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rw, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rw, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rw, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, r, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rx, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rx, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rx, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rx, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rx, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rx, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, r, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, rwx, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, rwx, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, rwx, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, rwx, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, rwx, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, rwx, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, r, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, w, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, w, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, w, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, w, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, w, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, w, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, r, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, wx, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, wx, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, wx, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, wx, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, wx, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, wx, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, r, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, r, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, r, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, r, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, r, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, r, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, r, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, r, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, r, x, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, r, x, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, r, x, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, r, x, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, r, x, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, r, x, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha1, r, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, r, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, r, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, r, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, r, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, r, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, r, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, r, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, r, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rw, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rw, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rx, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rx, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rx, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rx, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rx, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rx, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rw, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, rwx, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, rwx, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, rwx, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rw, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, w, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, w, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, w, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, w, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, w, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, w, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rw, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, wx, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, wx, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, wx, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, wx, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, wx, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, wx, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rw, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rw, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rw, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rw, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rw, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rw, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rw, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rw, x, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rw, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rw, x, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rw, x, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rw, x, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rw, x, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rw, x, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha1, rw, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rw, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rw, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, r, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, r, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, r, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, r, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, r, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, r, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rw, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rw, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rw, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rw, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rw, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rw, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, rwx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, rwx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, rwx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, rwx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, w, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, w, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, w, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, w, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, w, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, w, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, wx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, wx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, wx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, wx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, wx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, wx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rx, x, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rx, x, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rx, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rx, x, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rx, x, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rx, x, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rx, x, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha1, rx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, r, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, r, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, r, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, r, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, r, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, r, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, rwx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rw, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rw, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rw, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, rwx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, rwx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, rwx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, w, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, w, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, w, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, w, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, w, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, w, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, rwx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, wx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, wx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, wx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, rwx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, rwx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, rwx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, rwx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, rwx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, rwx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, rwx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, rwx, x, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, rwx, x, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, rwx, x, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, rwx, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, rwx, x, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, rwx, x, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, rwx, x, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha1, rwx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, rwx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, rwx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, r, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, r, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, r, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, r, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, r, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, r, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, w, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rw, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rw, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rw, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rw, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rw, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rw, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, w, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rx, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rx, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rx, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rx, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rx, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rx, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, w, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, rwx, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, rwx, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, rwx, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, rwx, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, rwx, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, rwx, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, w, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, w, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, wx, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, wx, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, wx, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, wx, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, wx, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, wx, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, w, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, w, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, w, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, w, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, w, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, w, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, w, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, w, x, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, w, x, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, w, x, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, w, x, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, w, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, w, x, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, w, x, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha1, w, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, w, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, w, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, r, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, r, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, r, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, r, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, r, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, r, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, wx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rw, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rw, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rw, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rw, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rw, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rw, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, wx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, wx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, rwx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, rwx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, rwx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, wx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, w, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, w, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, w, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, w, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, w, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, w, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, wx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, wx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, wx, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, wx, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, wx, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, wx, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, wx, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, wx, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, wx, x, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, wx, x, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, wx, x, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, wx, x, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, wx, x, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, wx, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, wx, x, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha1, wx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, wx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, wx, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, r, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rw, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, r, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, r, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, rwx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, r, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, w, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, r, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, wx, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, r, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, rw) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, rx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, w) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, wx) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, r, x, x) -> (0, 1, 1) OK +acl_userdir(_alpha2, x, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, r, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, r, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rw, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rw, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rw, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, rwx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rw, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, w, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rw, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, wx, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rw, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, r) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, rx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, w) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, wx) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rw, x, x) -> (0, 0, 1) OK +acl_userdir(_alpha2, x, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rw, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, r, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rw, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, rwx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, w, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, wx, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, r) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, rw) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, w) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, wx) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rx, x, x) -> (0, 1, 0) OK +acl_userdir(_alpha2, x, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, r, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, rwx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rw, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, rwx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, rwx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, rwx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, w, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, rwx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, wx, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, rwx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, r) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, rw) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, rx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, w) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, wx) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, rwx, x, x) -> (0, 0, 0) OK +acl_userdir(_alpha2, x, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, rwx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, r, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, w, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rw, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, w, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, w, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, rwx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, w, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, w, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, wx, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, w, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, r) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, rw) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, rx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, wx) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, w, x, x) -> (1, 0, 1) OK +acl_userdir(_alpha2, x, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, w, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, r, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, wx, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rw, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, wx, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, wx, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, rwx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, wx, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, w, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, wx, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, wx, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, r) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, rw) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, rx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, w) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, wx, x, x) -> (1, 0, 0) OK +acl_userdir(_alpha2, x, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, wx, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, rw) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, rx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, rwx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, w) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, wx) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, r, x) -> (0, 1, 1) OK +acl_userdir(_alpha3, x, x, r, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, r) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, rx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, rwx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, w) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, wx) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rw, x) -> (0, 0, 1) OK +acl_userdir(_alpha3, x, x, rw, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, r) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, rw) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, rwx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, w) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, wx) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rx, x) -> (0, 1, 0) OK +acl_userdir(_alpha3, x, x, rx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, r) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, rw) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, rx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, w) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, wx) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, rwx, x) -> (0, 0, 0) OK +acl_userdir(_alpha3, x, x, rwx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, r) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, rw) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, rx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, rwx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, wx) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, w, x) -> (1, 0, 1) OK +acl_userdir(_alpha3, x, x, w, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, r) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, rw) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, rx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, rwx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, w) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, wx, x) -> (1, 0, 0) OK +acl_userdir(_alpha3, x, x, wx, x) -> (1, 1, 0) OK +acl_userdir(_alpha0, x, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, r) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, r) -> (0, 1, 1) OK +acl_userdir(_alpha0, x, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, rw) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, rw) -> (0, 0, 1) OK +acl_userdir(_alpha0, x, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, rx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, rx) -> (0, 1, 0) OK +acl_userdir(_alpha0, x, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, rwx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, rwx) -> (0, 0, 0) OK +acl_userdir(_alpha0, x, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, w) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, w) -> (1, 0, 1) OK +acl_userdir(_alpha0, x, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, wx) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, wx) -> (1, 0, 0) OK +acl_userdir(_alpha0, x, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha1, x, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha2, x, x, x, x) -> (1, 1, 0) OK +acl_userdir(_alpha3, x, x, x, x) -> (1, 1, 0) OK +9604 tests run, 0 failed diff --git a/regress/sys/ffs2/acl/acl_userdir/acl_userdir.sh b/regress/sys/ffs2/acl/acl_userdir/acl_userdir.sh new file mode 100644 index 0000000..474f6bb --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userdir/acl_userdir.sh @@ -0,0 +1,139 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This test asserts that permissions are correctly enforced when four distinct +# users try to access a directory. For every combination possible, the followings steps are +# performed: +# +# (1) Try to inspect the contents of a directory (requires *READ* access). +# (2) Change the working directory (requires *EXEC* access in destination). +# (3) Move a directory (requires *WRITE* access). +# +# All tests are checked for success and failure when expected, in a total of +# 4 (users) * 7^4 (permissions) = 9604 individual tests. + +ALPHA="0 1 2 3" +MODES="r rw rx rwx w wx x" +RUN=0 +FAILED=0 + +assert() { + local result="OK" + if [ $7 -eq 0 ]; then + if [ ${perm[$2]} = "w" ] || [ ${perm[$2]} = "wx" ] || + [ ${perm[$2]} = "x" ]; then + echo "Inappropriate read access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "r" ] || [ ${perm[$2]} = "rw" ] || + [ ${perm[$2]} = "rx" ] || [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate read access denial!" + result="FAILED" + fi + fi + if [ $8 -eq 0 ]; then + if [ ${perm[$2]} = "r" ] || [ ${perm[$2]} = "rx" ] || + [ ${perm[$2]} = "x" ]; then + echo "Inappropriate write access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "w" ] || [ ${perm[$2]} = "rw" ] || + [ ${perm[$2]} = "wx" ] || [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate write access denial!" + result="FAILED" + fi + fi + if [ $9 -eq 0 ]; then + if [ ${perm[$2]} = "r" ] || [ ${perm[$2]} = "rw" ] || + [ ${perm[$2]} = "w" ]; then + echo "Inappropriate execution access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "x" ] || [ ${perm[$2]} = "rx" ] || + [ ${perm[$2]} = "wx" ] || [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate execution access denial!" + result="FAILED" + fi + fi + echo "$1(_alpha$2, $3, $4, $5, $6) -> ($7, $8, $9) $result" + if [ $result = "FAILED" ]; then + FAILED=`expr $FAILED + 1` + fi +} + +test() { + local dir1=`mktemp -d -p $WRKDIR` + local dir2=`mktemp -d -p $WRKDIR` + local r w x + + chown _alpha$1 $WRKDIR $dir2 2>/dev/null + setfacl -m \ + u:_alpha0:$2,u:_alpha1:$3,u:_alpha2:$4,u:_alpha3:$5 $dir1 2>/dev/null + + sudo -u _alpha$1 ls $dir1 2>/dev/null + r=$? + sudo -u _alpha$1 sh -c "cd $dir1" 2>/dev/null + x=$? + # Note: There is a difference in behaviour between OpenBSD and Linux + # regarding the renaming of directories. Linux does *not* require + # write permission if the directory is being moved within a given + # 'parent' directory, while OpenBSD does. + sudo -u _alpha$1 mv $dir1 $dir2 2>/dev/null + w=$? + + assert acl_userdir $1 $2 $3 $4 $5 $r $w $x + rm -rf $dir1 $dir2 + RUN=`expr $RUN + 1` +} + +if [ -z $1 ]; then + echo "Please specify a work directory as a first argument." + exit 1 +fi + +WRKDIR=$1 +echo Starting tests... + +for mode in $MODES; do + perm[0]=$mode + for mode in $MODES; do + perm[1]=$mode + for mode in $MODES; do + perm[2]=$mode + for mode in $MODES; do + perm[3]=$mode + for alpha in $ALPHA; do + test $alpha ${perm[0]} ${perm[1]} \ + ${perm[2]} ${perm[3]} + done + done + done + done +done + +echo $RUN tests run, $FAILED failed diff --git a/regress/sys/ffs2/acl/acl_userfile/Makefile b/regress/sys/ffs2/acl/acl_userfile/Makefile new file mode 100644 index 0000000..9cb41c5 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userfile/Makefile @@ -0,0 +1,17 @@ +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress: + sh ${.CURDIR}/acl_userfile.sh ${FAKEMNT} |\ + diff -u - ${.CURDIR}/acl_userfile.out + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && exec ${MAKE} run-regress) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/acl/acl_userfile/acl_userfile.out b/regress/sys/ffs2/acl/acl_userfile/acl_userfile.out new file mode 100644 index 0000000..157d195 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userfile/acl_userfile.out @@ -0,0 +1,9606 @@ +Starting tests... +acl_userfile(_alpha0, r, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, r, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, r, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, r, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, r, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, r, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, r, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, r, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, r, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, rw, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, rw, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, rw, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, rw, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, rw, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, rw, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rw, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rw, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rw, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rw, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rw, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rw, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, rw, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, rw, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, rw, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, r, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rw, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rw, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rw, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rw, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rw, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rw, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rw, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rw, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rw, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, r, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rx, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rx, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rx, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rx, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rx, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rx, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, r, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, rwx, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, rwx, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, rwx, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, rwx, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, rwx, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, rwx, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, r, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, w, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, w, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, r, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, w, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, w, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, w, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, r, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, w, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, w, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, w, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, w, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, w, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, w, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, r, w, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, r, w, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha1, r, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, w, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, w, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, w, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, w, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, w, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, w, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, w, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, w, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, w, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, r, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, wx, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, wx, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, wx, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, wx, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, wx, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, wx, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, r, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, r, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, r, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, r, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, r, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, r, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, r, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, r, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, r, x, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, r, x, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, r, x, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, r, x, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, r, x, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, r, x, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha1, r, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, r, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, r, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, r, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, r, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, r, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, r, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, r, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, r, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, r, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, r, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, r, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, r, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, r, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, r, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, rw, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, r, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, r, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, r, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, r, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, r, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, r, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, r, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, r, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rw, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, rw, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, rw, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, rw, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, rw, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, rw, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rw, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rx, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rx, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rx, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rx, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rx, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rx, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rw, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, rwx, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, rwx, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, rwx, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, rwx, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, rwx, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rw, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, w, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, w, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, w, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, rw, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, w, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, rw, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, w, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, w, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, w, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, w, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, rw, w, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, rw, w, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha1, rw, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, w, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, w, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, w, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, w, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, w, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, w, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, w, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, w, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rw, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, wx, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, wx, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, wx, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, wx, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, wx, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, wx, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rw, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rw, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rw, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rw, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rw, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rw, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rw, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rw, x, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rw, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rw, x, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rw, x, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rw, x, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rw, x, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rw, x, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha1, rw, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rw, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rw, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, r, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, r, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, r, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, r, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, r, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, r, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rw, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rw, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rw, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rw, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rw, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rw, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, rwx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, rwx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, rwx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, rwx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, rwx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, rwx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, w, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, w, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, w, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, w, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, w, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, w, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, wx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, wx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, wx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, wx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, wx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, wx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rx, x, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rx, x, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rx, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rx, x, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rx, x, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rx, x, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rx, x, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha1, rx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, r, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, r, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, r, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, r, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, r, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, r, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, rwx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rw, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rw, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rw, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rw, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rw, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, rwx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, rwx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, rwx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, w, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, w, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, w, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, w, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, w, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, w, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, rwx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, wx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, wx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, wx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, wx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, wx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, rwx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, rwx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, rwx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, rwx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, rwx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, rwx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, rwx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, rwx, x, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, rwx, x, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, rwx, x, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, rwx, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, rwx, x, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, rwx, x, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, rwx, x, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha1, rwx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, rwx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, rwx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, r, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, r, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, r, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, r, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, r, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, r, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, r, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, rw, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, r, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, r, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, rw, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, r, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, r, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, r, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, r, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, r, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, r, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, r, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, r, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, w, rw) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, r, w, w) -> (0, 1, 1) OK +acl_userfile(_alpha2, w, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, r, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, r, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, r, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, r, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, r, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, r, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, r, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, r, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, r, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, w, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, r, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, rw, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, rw, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, rw, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, rw, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, r, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, rw, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, rw, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, rw, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, rw, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, rw, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, rw, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rw, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rw, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rw, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rw, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rw, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rw, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, w, r) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, rw, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, rw, w, w) -> (0, 0, 1) OK +acl_userfile(_alpha2, w, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rw, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rw, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rw, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rw, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rw, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rw, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rw, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rw, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rw, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, w, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rx, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rx, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rx, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rx, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rx, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rx, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, w, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, rwx, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, rwx, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, rwx, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, rwx, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, rwx, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, rwx, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, w, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, w, r, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, w, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, r, rw) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, w, r, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, r, w) -> (0, 1, 1) OK +acl_userfile(_alpha3, w, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, rw, r) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, w, rw, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, w, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, w, rw, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, rw, w) -> (0, 0, 1) OK +acl_userfile(_alpha3, w, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, w, r) -> (0, 1, 1) OK +acl_userfile(_alpha0, w, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, w, rw) -> (0, 0, 1) OK +acl_userfile(_alpha0, w, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, w, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, w, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, wx, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, wx, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, wx, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, wx, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, wx, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, wx, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, w, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, w, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, w, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, w, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, w, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, w, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, w, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, w, x, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, w, x, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, w, x, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, w, x, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, w, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, w, x, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, w, x, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha1, w, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, w, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, w, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, r, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, r, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, r, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, r, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, r, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, r, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, wx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rw, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rw, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rw, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rw, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rw, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rw, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, wx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, wx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, rwx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, rwx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, rwx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, rwx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, rwx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, wx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, w, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, w, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, w, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, w, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, w, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, w, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, wx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, wx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, wx, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, wx, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, wx, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, wx, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, wx, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, wx, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, wx, x, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, wx, x, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, wx, x, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, wx, x, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, wx, x, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, wx, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, wx, x, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha1, wx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, wx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, wx, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, r, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rw, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, r, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, r, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, rwx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, r, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, w, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, r, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, wx, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, r, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, rw) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, rx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, w) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, wx) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, r, x, x) -> (0, 1, 127) OK +acl_userfile(_alpha2, x, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, r, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, r, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rw, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rw, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rw, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, rwx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rw, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, w, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rw, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, wx, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rw, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, r) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, rx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, w) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, wx) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rw, x, x) -> (0, 0, 127) OK +acl_userfile(_alpha2, x, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rw, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, r, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rw, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, rwx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, w, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, wx, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, r) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, rw) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, w) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, wx) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rx, x, x) -> (0, 1, 0) OK +acl_userfile(_alpha2, x, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, r, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, rwx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rw, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, rwx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, rwx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, rwx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, w, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, rwx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, wx, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, rwx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, r) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, rw) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, rx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, w) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, wx) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, rwx, x, x) -> (0, 0, 0) OK +acl_userfile(_alpha2, x, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, rwx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, r, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, w, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rw, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, w, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, w, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, rwx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, w, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, w, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, wx, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, w, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, r) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, rw) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, rx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, wx) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, w, x, x) -> (1, 0, 127) OK +acl_userfile(_alpha2, x, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, w, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, r, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, wx, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rw, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, wx, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, wx, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, rwx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, wx, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, w, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, wx, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, wx, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, r) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, rw) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, rx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, w) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, wx, x, x) -> (1, 0, 1) OK +acl_userfile(_alpha2, x, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, wx, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, rw) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, rx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, rwx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, w) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, wx) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, r, x) -> (0, 1, 127) OK +acl_userfile(_alpha3, x, x, r, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, r) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, rx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, rwx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, w) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, wx) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rw, x) -> (0, 0, 127) OK +acl_userfile(_alpha3, x, x, rw, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, r) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, rw) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, rwx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, w) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, wx) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rx, x) -> (0, 1, 0) OK +acl_userfile(_alpha3, x, x, rx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, r) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, rw) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, rx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, w) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, wx) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, rwx, x) -> (0, 0, 0) OK +acl_userfile(_alpha3, x, x, rwx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, r) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, rw) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, rx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, rwx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, wx) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, w, x) -> (1, 0, 127) OK +acl_userfile(_alpha3, x, x, w, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, r) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, rw) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, rx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, rwx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, w) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, wx, x) -> (1, 0, 1) OK +acl_userfile(_alpha3, x, x, wx, x) -> (1, 1, 1) OK +acl_userfile(_alpha0, x, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, r) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, r) -> (0, 1, 127) OK +acl_userfile(_alpha0, x, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, rw) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, rw) -> (0, 0, 127) OK +acl_userfile(_alpha0, x, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, rx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, rx) -> (0, 1, 0) OK +acl_userfile(_alpha0, x, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, rwx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, rwx) -> (0, 0, 0) OK +acl_userfile(_alpha0, x, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, w) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, w) -> (1, 0, 127) OK +acl_userfile(_alpha0, x, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, wx) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, wx) -> (1, 0, 1) OK +acl_userfile(_alpha0, x, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha1, x, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha2, x, x, x, x) -> (1, 1, 1) OK +acl_userfile(_alpha3, x, x, x, x) -> (1, 1, 1) OK +9604 tests run, 0 failed diff --git a/regress/sys/ffs2/acl/acl_userfile/acl_userfile.sh b/regress/sys/ffs2/acl/acl_userfile/acl_userfile.sh new file mode 100644 index 0000000..671d426 --- /dev/null +++ b/regress/sys/ffs2/acl/acl_userfile/acl_userfile.sh @@ -0,0 +1,131 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This test asserts that permissions are correctly enforced when four distinct +# users try to access a file. For every combination possible, the followings steps are +# performed: +# +# (1) Try to read from the file. +# (2) Try to execute the file. +# (3) Try to write to the file. +# +# All tests are checked for success and failure when expected, in a total of +# 4 (users) * 7^4 (permissions) = 9604 individual tests. + +ALPHA="0 1 2 3" +MODES="r rw rx rwx w wx x" +RUN=0 +FAILED=0 + +assert() { + local result="OK" + if [ $7 -eq 0 ]; then + if [ ${perm[$2]} = "w" ] || [ ${perm[$2]} = "wx" ] || + [ ${perm[$2]} = "x" ]; then + echo "Inappropriate read access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "r" ] || [ ${perm[$2]} = "rw" ] || + [ ${perm[$2]} = "rx" ] || [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate read access denial!" + result="FAILED" + fi + fi + if [ $8 -eq 0 ]; then + if [ ${perm[$2]} = "r" ] || [ ${perm[$2]} = "rx" ] || + [ ${perm[$2]} = "x" ]; then + echo "Inappropriate write access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "w" ] || [ ${perm[$2]} = "rw" ] || + [ ${perm[$2]} = "wx" ] || [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate write access denial!" + result="FAILED" + fi + fi + if [ $9 -eq 0 ]; then + if [ ${perm[$2]} != "rx" ] && [ ${perm[$2]} != "rwx" ]; then + echo "Inappropriate execution access granted!" + result="FAILED" + fi + else + if [ ${perm[$2]} = "rx" ] && [ ${perm[$2]} = "rwx" ]; then + echo "Inappropriate execution access denial!" + result="FAILED" + fi + fi + echo "$1(_alpha$2, $3, $4, $5, $6) -> ($7, $8, $9) $result" + if [ $result = "FAILED" ]; then + FAILED=`expr $FAILED + 1` + fi +} + +test() { + local file=`mktemp -p $WRKDIR` + local r w x + + setfacl -m \ + u:_alpha0:$2,u:_alpha1:$3,u:_alpha2:$4,u:_alpha3:$5 $file 2>/dev/null + + sudo -u _alpha$1 cat $file 2>/dev/null + r=$? + sudo -u _alpha$1 $file 2>/dev/null + x=$? + sudo -u _alpha$1 sh -c "echo 1 > $file" 2>/dev/null + w=$? + + assert acl_userfile $1 $2 $3 $4 $5 $r $w $x + rm -rf $dir $file + RUN=`expr $RUN + 1` +} + +if [ -z $1 ]; then + echo "Please specify a work directory as a first argument." + exit 1 +fi + +WRKDIR=$1 +echo Starting tests... + +for mode in $MODES; do + perm[0]=$mode + for mode in $MODES; do + perm[1]=$mode + for mode in $MODES; do + perm[2]=$mode + for mode in $MODES; do + perm[3]=$mode + for alpha in $ALPHA; do + test $alpha ${perm[0]} ${perm[1]} \ + ${perm[2]} ${perm[3]} + done + done + done + done +done + +echo $RUN tests run, $FAILED failed diff --git a/regress/sys/ffs2/acl/cleanup.sh b/regress/sys/ffs2/acl/cleanup.sh new file mode 100644 index 0000000..dabc606 --- /dev/null +++ b/regress/sys/ffs2/acl/cleanup.sh @@ -0,0 +1,70 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This script ensures that all groups and users created for the ACL regression +# test suite are correctly removed from the host system. + +echo Cleaning up groups and users... + +# Remove '_beta' groups. +for n in 0 1; do + match=`getent group _beta$n | cut -d : -f 4` + pattern="_alpha"`expr $n + $n`",_alpha"`expr $n + $n + 1` + if [ "$match" == "$pattern" ]; then + groupdel _beta$n + if [ $? -eq 0 ]; then + echo "Removed group '_beta$n'." + else + echo "Error removing group '_beta$n'." + fi + fi +done + +# Remove '_gamma' groups. +for n in 0 1; do + match=`getent group _gamma$n | cut -d : -f 4` + pattern="_alpha"`expr $n`",_alpha"`expr $n + 2` + if [ "$match" == "$pattern" ]; then + groupdel _gamma$n + if [ $? -eq 0 ]; then + echo "Removed group '_gamma$n'." + else + echo "Error removing group '_gamma$n'." + fi + fi +done + +# Remove '_alpha' users. +for n in 0 1 2 3; do + match=`getent passwd _alpha$n | cut -d : -f 5` + pattern="_alpha$n acl test user" + if [ "$match" == "$pattern" ]; then + userdel _alpha$n + if [ $? -eq 0 ]; then + echo "Removed user '_alpha$n'." + else + echo "Error removing user '_alpha$n'." + fi + fi +done diff --git a/regress/sys/ffs2/acl/setup.sh b/regress/sys/ffs2/acl/setup.sh new file mode 100644 index 0000000..b63d0cc --- /dev/null +++ b/regress/sys/ffs2/acl/setup.sh @@ -0,0 +1,111 @@ +# Copyright (c) 2008 GeNUA mbH +# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# This script populates the host system with groups and users needed by the ACL +# regression tests. In case of error, partial modifications are reverted. + +# Subroutines (have to come first). + +addgroup() { + local group=$1$2 + getent group $group >/dev/null + if [ $? -eq 2 ]; then + groupadd $group + if [ $? -eq 0 ]; then + echo "Added group '$group'." + set -A added_groups ${added_groups[@]} $group + else + echo "Error adding group '$group'." + revert + fi + fi +} + +adduser() { + local home="/var/empty" + local shell="/sbin/nologin" + local user=$1$2 + useradd -c "$user acl test user" -d $home -s $shell -g =uid $user + if [ $? -eq 0 ]; then + echo "Added user '$user'." + set -A added_users ${added_users[@]} $user + else + echo "Error adding user '$user'." + revert + fi +} + +revert() { + echo Reverting... + for user in ${added_users[@]}; do + userdel $user + if [ $? -eq 0 ]; then + echo "Removed user '$user'." + else + echo "Error removing user '$user'." + fi + done + for group in ${added_groups[@]}; do + groupdel $group + if [ $? -eq 0 ]; then + echo "Removed group '$group'." + else + echo "Error removing group '$group'." + fi + done + exit 1 +} + +# End of subroutines. + +set -A added_users +set -A added_groups + +echo Setting up groups and users... + +for group in _beta0 _beta1 _gamma0 _gamma1; do + getent group $group >/dev/null + if [ $? -eq 0 ]; then + echo "Error, group '$group' already exists." + exit 1 # Nothing to revert at this point. + fi +done + +for alpha in 0 1 2 3; do + beta=`expr $alpha / 2` + gamma=`expr $alpha % 2` + adduser _alpha $alpha + addgroup _beta $beta + addgroup _gamma $gamma + usermod -G _beta$beta,_gamma$gamma _alpha$alpha + if [ $? -eq 0 ]; then + echo -n "Inserted user '_alpha$alpha' in groups " + echo "'_beta$beta' and '_gamma$gamma'." + else + echo -n "Error inserting user $alpha$alpha in groups " + echo "'_beta$beta' and '_gamma$gamma'." + fi +done + +exit 0 diff --git a/regress/sys/ffs2/extattr/Makefile b/regress/sys/ffs2/extattr/Makefile new file mode 100644 index 0000000..115a590 --- /dev/null +++ b/regress/sys/ffs2/extattr/Makefile @@ -0,0 +1,20 @@ +FSIZE?= 2048 +BSIZE?= 16384 +COUNT?= 128 +VND?= vnd0 + +mount: + dd if=/dev/zero of=${.CURDIR}/fakedisk bs=${BSIZE} count=${COUNT} + mkdir ${.CURDIR}/fakemount + vnconfig s${VND} ${.CURDIR}/fakedisk + newfs -f ${FSIZE} -b ${BSIZE} -O 2 /dev/rs${VND}c + mount /dev/s${VND}c ${.CURDIR}/fakemount + +unmount: + -umount ${.CURDIR}/fakemount + -vnconfig -u s${VND} + -rm -rf ${.CURDIR}/fakedisk ${.CURDIR}/fakemount + +SUBDIR= extattr_limit extattr_link extattr_priv extattr_stat extattr_truncate + +.include diff --git a/regress/sys/ffs2/extattr/README b/regress/sys/ffs2/extattr/README new file mode 100644 index 0000000..a5e937b --- /dev/null +++ b/regress/sys/ffs2/extattr/README @@ -0,0 +1,12 @@ +While most of these tests are not implementation-specific per se, they are here +because FFS2 is the only file system to support extended attributes in OpenBSD. +In order to perform them, it is necessary: + +(1) To have superuser privileges. +(2) To be running a kernel compiled with options 'FFS2' and 'EXTATTR'. +(3) To have a vacant vnd(4) slot represented in 'VND' (an environment variable). + +If not set, 'VND' is assumed as 'vnd0'. + +A summary of what each test does can be found in the respective '.c' file, +in a comment above the 'main()' function. diff --git a/regress/sys/ffs2/extattr/extattr_limit/Makefile b/regress/sys/ffs2/extattr/extattr_limit/Makefile new file mode 100644 index 0000000..06e33b3 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_limit/Makefile @@ -0,0 +1,24 @@ +PROG= extattr_limit +TOP= ${.CURDIR}/.. +TESTS?= 2048 4096 4096 4096 2048 8192 4096 8192 8192 8192 2048 16384 \ + 4096 16384 8192 16384 16384 16384 4096 32768 8192 32768 16384 \ + 32768 32768 32768 +FAKEMNT= ${TOP}/fakemount + +run-regress-${PROG}: + ./${PROG} /dev/rsvnd0c ${TMPFILE} + +regress: +.for FSIZE BSIZE in ${TESTS} + (cd ${TOP} && exec ${MAKE} FSIZE=${FSIZE} BSIZE=${BSIZE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPFILE=`mktemp ${FAKEMNT}/extattr.XXXXXXXX` \ + run-regress-${PROG}) + (cd ${TOP} && exec ${MAKE} unmount) +.endfor + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/extattr/extattr_limit/extattr_limit.c b/regress/sys/ffs2/extattr/extattr_limit/extattr_limit.c new file mode 100644 index 0000000..715bddd --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_limit/extattr_limit.c @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include + +#include +#include + +#include +#include +#include +#include +#include + +union { + struct fs fs; + char pad[MAXBSIZE]; +} fsu; + +#define ffs fsu.fs + +/* + * Check that the expected size limit for the extended attributes area of an + * inode on a given file system is reachable and correctly enforced. + */ +int +main(int argc, char **argv) +{ + int attrnamespace, fd, i, max, n; + int sbtry[] = SBLOCKSEARCH; + void *buf; + + if (argc != 3) + errx(1, "wrong usage"); + + fd = open(argv[1], O_RDONLY, 0); + if (fd < 0) + err(1, "open 1"); + + for (i = 0; sbtry[i] != -1; i++) { + n = pread(fd, &fsu, SBLOCKSIZE, (off_t)sbtry[i]); + if (n == SBLOCKSIZE && ffs.fs_magic == FS_UFS2_MAGIC && + ffs.fs_sblockloc == sbtry[i] && ffs.fs_bsize <= MAXBSIZE && + ffs.fs_bsize > sizeof(struct fs)) + break; + } + + if (sbtry[i] == -1) + errx(1, "could not locate file system superblock"); + + close(fd); + + fd = open(argv[2], O_WRONLY, 0); + if (fd < 0) + err(1, "open 2"); + + /* + * NXADDR is the number of blocks reserved for extended attributes. The + * '7' in the math below is to account for the record size (4 bytes), + * attribute namespace (1 byte), length of second padding (1 byte) and + * length of attribute name (1 byte). Please refer to ffs_ea_set() for + * a detailed description of how extended attributes are laid out on + * the file system. Finally, it should be noted that the two paddings + * will always be zero due to the attribute name being "t" and the + * block size being a power of 2 bigger than 2^3. + */ + + if (ffs.fs_bsize > INT_MAX / NXADDR) + errx(1, "bogus blksize"); + + attrnamespace = EXTATTR_NAMESPACE_USER; + buf = NULL; + max = NXADDR * ffs.fs_bsize - 7; + n = 0; + + for (;;) { + buf = realloc(buf, n); + if (buf == NULL) + err(1, NULL); + if (extattr_set_fd(fd, attrnamespace, "t", buf, n) < 0) { + if (errno != ENOSPC) + err(1, "extattr_set_fd %d", n); + if (n != max) + errx(1, "wrote %d, expected %d\n", n, max); + break; + } + if (n > max) + errx(1, "wrote %d, expected %d\n", n, max); + n++; + } + + exit(0); +} diff --git a/regress/sys/ffs2/extattr/extattr_link/Makefile b/regress/sys/ffs2/extattr/extattr_link/Makefile new file mode 100644 index 0000000..71ebbe2 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_link/Makefile @@ -0,0 +1,20 @@ +PROG= extattr_link +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress-${PROG}: + ln -sf ${TMPFILE} ${TMPLINK} + ./${PROG} ${TMPFILE} ${TMPLINK} + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPFILE=`mktemp ${FAKEMNT}/extattr.XXXXXXXX` \ + TMPLINK=`mktemp -u ${FAKEMNT}/extattr.XXXXXXXX` run-regress-${PROG}) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/extattr/extattr_link/extattr_link.c b/regress/sys/ffs2/extattr/extattr_link/extattr_link.c new file mode 100644 index 0000000..a928e4b --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_link/extattr_link.c @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include + +#include +#include +#include +#include +#include + +/* + * Check that the extattr_*_link() and extattr_*_file() functions operate on + * different objects when passed a path to a symbolic link. + */ +int +main(int argc, char **argv) +{ + char ch; + int attrnamespace, fd; + ssize_t n; + + if (argc != 3) + errx(1, "wrong usage"); + + /* Open the file; operate on the symlink. */ + fd = open(argv[1], O_RDWR, 0); + if (fd < 0) + err(1, "open"); + + attrnamespace = EXTATTR_NAMESPACE_USER; + + if (extattr_set_file(argv[2], attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_file"); + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 1"); + if (extattr_get_file(argv[2], attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_file"); + n = extattr_list_file(argv[2], attrnamespace, &ch, sizeof(ch)); + if (n < 0) + err(1, "extattr_list_file"); + if (n != sizeof(ch)) + errx(1, "extattr_list_file"); + + if (extattr_delete_file(argv[2], attrnamespace, "t") < 0) + err(1, "extattr_delete_file"); + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) > 0) + errx(1, "extattr_get_fd 2"); + + /* + * Since symlinks can't be opened, there is no way to check the success + * of extattr_set_link() by calling extattr_get_fd(), as we do for + * extattr_set_file() above. Consequently, the following tests do not + * assert that the attributes were set in the symlink; but just that + * they weren't set in the file. + */ + + if (extattr_set_link(argv[2], attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_link"); + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) > 0) + errx(1, "extattr_get_fd 3"); + if (extattr_get_link(argv[2], attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_link 1"); + n = extattr_list_link(argv[2], attrnamespace, &ch, sizeof(ch)); + if (n < 0) + err(1, "extattr_list_link"); + if (n != sizeof(ch)) + errx(1, "extattr_list_link"); + + if (extattr_delete_link(argv[2], attrnamespace, "t") < 0) + err(1, "extattr_delete_link"); + if (extattr_get_link(argv[2], attrnamespace, "t", &ch, sizeof(ch)) > 0) + err(1, "extattr_get_link 2"); + + exit(0); +} diff --git a/regress/sys/ffs2/extattr/extattr_priv/Makefile b/regress/sys/ffs2/extattr/extattr_priv/Makefile new file mode 100644 index 0000000..103b659 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_priv/Makefile @@ -0,0 +1,19 @@ +PROG= extattr_priv +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress-${PROG}: + ./${PROG} ${TMPFILE} + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPFILE=`mktemp ${FAKEMNT}/extattr.XXXXXXXX` \ + run-regress-${PROG}) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/extattr/extattr_priv/extattr_priv.c b/regress/sys/ffs2/extattr/extattr_priv/extattr_priv.c new file mode 100644 index 0000000..a1e4fe9 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_priv/extattr_priv.c @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include + +#include +#include +#include +#include +#include +#include + +/* + * Check that unprivileged users cannot access the system namespace. + */ +int +main(int argc, char **argv) +{ + char ch; + int attrnamespace, fd; + struct passwd *nobody; + + if (argc != 2) + errx(1, "wrong usage"); + + if (getuid() != 0) + errx(1, "must be run as root"); + + fd = open(argv[1], O_RDWR, 0); + if (fd < 0) + err(1, "open"); + + nobody = getpwnam("nobody"); + if (nobody == NULL) + errx(1, "passwd"); + if (fchown(fd, nobody->pw_uid, nobody->pw_gid) < 0) + err(1, "fchown"); + + attrnamespace = EXTATTR_NAMESPACE_SYSTEM; + + if (extattr_set_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_fd 1"); + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 1"); + + setreuid(-1, nobody->pw_uid); + + if (extattr_set_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) { + if (errno != EPERM) + errx(1, "unexpected errno 1"); + } else + err(1, "extattr_set_fd 2"); + + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) { + if (errno != EPERM) + errx(1, "unexpected errno 2"); + } else + err(1, "extattr_get_fd 2"); + + exit(0); +} diff --git a/regress/sys/ffs2/extattr/extattr_stat/Makefile b/regress/sys/ffs2/extattr/extattr_stat/Makefile new file mode 100644 index 0000000..fbdef57 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_stat/Makefile @@ -0,0 +1,19 @@ +PROG= extattr_stat +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress-${PROG}: + ./${PROG} ${TMPFILE} + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPFILE=`mktemp ${FAKEMNT}/extattr.XXXXXXXX` \ + run-regress-${PROG}) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/extattr/extattr_stat/extattr_stat.c b/regress/sys/ffs2/extattr/extattr_stat/extattr_stat.c new file mode 100644 index 0000000..26c1307 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_stat/extattr_stat.c @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include +#include + +#include +#include +#include +#include + +/* + * Check that the returned fields of 'struct stat' reflect operations in the + * extended attribute area accordingly. + */ +int +main(int argc, char **argv) +{ + char ch; + int attrnamespace, fd; + struct stat stat1, stat2; + + if (argc != 2) + errx(1, "wrong usage"); + + fd = open(argv[1], O_RDWR, 0); + if (fd < 0) + err(1, "open"); + + attrnamespace = EXTATTR_NAMESPACE_USER; + + if (fstat(fd, &stat1) < 0) + err(1, "fstat 1"); + + sleep(1); + + if (extattr_set_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_fd"); + + if (fstat(fd, &stat2) < 0) + err(1, "fstat 2"); + + if (!memcmp(&stat1.st_mtime, &stat2.st_mtime, sizeof(stat1.st_mtime))) + errx(1, "st_mtime didn't change"); + if (!memcmp(&stat1.st_ctime, &stat2.st_ctime, sizeof(stat1.st_ctime))) + errx(1, "st_ctime didn't change"); + + if (stat1.st_blocks == stat2.st_blocks) + errx(1, "st_blocks didn't change"); + if (stat1.st_size != stat2.st_size) + errx(1, "st_size changed"); + + sleep(1); + + if (extattr_get_fd(fd, attrnamespace, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 1"); + + if (fstat(fd, &stat1) < 0) + err(1, "fstat 3"); + + if (!memcmp(&stat1.st_atime, &stat2.st_atime, sizeof(stat1.st_atime))) + errx(1, "st_atime didn't change 1"); + + sleep(1); + + if (extattr_delete_fd(fd, attrnamespace, "t") < 0) + err(1, "extattr_delete_fd"); + + if (fstat(fd, &stat2) < 0) + err(1, "fstat 4"); + + if (!memcmp(&stat1.st_mtime, &stat2.st_mtime, sizeof(stat1.st_mtime))) + errx(1, "st_mtime didn't change"); + if (!memcmp(&stat1.st_ctime, &stat2.st_ctime, sizeof(stat1.st_ctime))) + errx(1, "st_ctime didn't change"); + + if (stat1.st_blocks == stat2.st_blocks) + errx(1, "st_blocks didn't change"); + if (stat1.st_size != stat2.st_size) + errx(1, "st_size changed"); + + sleep(1); + + if (extattr_list_fd(fd, attrnamespace, NULL, 0) < 0) + err(1, "extattr_list_fd"); + + if (fstat(fd, &stat1) < 0) + err(1, "fstat 5"); + + if (!memcmp(&stat1.st_atime, &stat2.st_atime, sizeof(stat1.st_atime))) + errx(1, "st_atime didn't change 2"); + + exit(0); +} diff --git a/regress/sys/ffs2/extattr/extattr_truncate/Makefile b/regress/sys/ffs2/extattr/extattr_truncate/Makefile new file mode 100644 index 0000000..7c01912 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_truncate/Makefile @@ -0,0 +1,19 @@ +PROG= extattr_truncate +TOP= ${.CURDIR}/.. +FAKEMNT= ${TOP}/fakemount + +run-regress-${PROG}: + ./${PROG} ${TMPFILE} + +regress: + (cd ${TOP} && exec ${MAKE} mount) + @(cd ${.CURDIR} && \ + exec ${MAKE} TMPFILE=`mktemp ${FAKEMNT}/extattr.XXXXXXXX` \ + run-regress-${PROG}) + (cd ${TOP} && exec ${MAKE} unmount) + +clean: + (cd ${TOP} && exec ${MAKE} unmount) + rm -f ${PROG} ${OBJS} + +.include diff --git a/regress/sys/ffs2/extattr/extattr_truncate/extattr_truncate.c b/regress/sys/ffs2/extattr/extattr_truncate/extattr_truncate.c new file mode 100644 index 0000000..2fe4774 --- /dev/null +++ b/regress/sys/ffs2/extattr/extattr_truncate/extattr_truncate.c @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 +#include + +#include +#include +#include +#include + +/* + * Check that extended attributes are preserved if the file is truncated. + */ +int +main(int argc, char **argv) +{ + char ch; + int attrnamespace1, attrnamespace2, fd; + + if (argc != 2) + errx(1, "wrong usage"); + + if (getuid() != 0) + errx(1, "must be run as root"); + + fd = open(argv[1], O_RDWR, 0); + if (fd < 0) + err(1, "open"); + + attrnamespace1 = EXTATTR_NAMESPACE_USER; + attrnamespace2 = EXTATTR_NAMESPACE_SYSTEM; + + if (extattr_set_fd(fd, attrnamespace1, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_fd 1"); + if (extattr_get_fd(fd, attrnamespace1, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 1"); + if (extattr_set_fd(fd, attrnamespace2, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_set_fd 2"); + if (extattr_get_fd(fd, attrnamespace2, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 2"); + + if (ftruncate(fd, 0) < 0) + err(1, "ftruncate"); + + if (extattr_get_fd(fd, attrnamespace1, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 3"); + if (extattr_get_fd(fd, attrnamespace2, "t", &ch, sizeof(ch)) < 0) + err(1, "extattr_get_fd 3"); + + exit(0); +} diff --git a/regress/sys/kern/Makefile b/regress/sys/kern/Makefile index f579c8b..a0fcb6f 100644 --- a/regress/sys/kern/Makefile +++ b/regress/sys/kern/Makefile @@ -1,13 +1,13 @@ # $OpenBSD: art $ -SUBDIR+= __syscall accept dup2 dup2_self exec_self execve exit extent -SUBDIR+= fcntl_dup +SUBDIR+= __syscall accept access dup2 dup2_self exec_self execve exit extent +SUBDIR+= fcntl_dup getpeereid getrusage gettimeofday itimer SUBDIR+= flock SUBDIR+= getpeereid getrusage gettimeofday itimer SUBDIR+= kqueue mbuf minherit SUBDIR+= mmap mmap2 mmap3 mmap-fail #SUBDIR+= mquery -SUBDIR+= nanosleep noexec pread preadv ptmget pwrite pwritev rcvtimeo +SUBDIR+= nanosleep noexec open pread preadv ptmget pwrite pwritev rcvtimeo #SUBDIR+= rfork SUBDIR+= rlimit-file signal signal-stress sigsuspend SUBDIR+= syscall sysvmsg sysvsem diff --git a/regress/sys/kern/access/Makefile b/regress/sys/kern/access/Makefile new file mode 100644 index 0000000..a6766b5 --- /dev/null +++ b/regress/sys/kern/access/Makefile @@ -0,0 +1,3 @@ +PROG= access + +.include diff --git a/regress/sys/kern/access/access.c b/regress/sys/kern/access/access.c new file mode 100644 index 0000000..f997510 --- /dev/null +++ b/regress/sys/kern/access/access.c @@ -0,0 +1,313 @@ +/* + * Copyright (c) 2001 Networks Associates Technology, Inc. + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * Written at NAI Labs at Network Associates by Robert Watson for the + * TrustedBSD Project. + * + * Work sponsored by Defense Advanced Research Projects Agency under the + * CHATS research program, CBOSS project. + * + * $FreeBSD: testaccess.c,v 1.4 2002/05/16 05:03:56 trhodes Exp $ + */ + +#include + +#include +#include +#include +#include +#include + +/* + * Regression test to check some basic cases and see if access() is + * using the correct portions of the process credential. + * This test relies on running with privilege, and on FFS filesystem + * semantics. Running the test in other environments may result + * in incorrect failure identification. + * + * Note that this may also break if filesystem access control is + * broken, or if the ability to check and set credentials is broken. + * + * Note that this test uses two hard-coded non-root UIDs; on multi-user + * systems, these UIDs may be in use by an untrusted user, in which + * case those users could interfere with the test. + */ + +#define ROOT_UID (uid_t)0 +#define WHEEL_GID (gid_t)0 +#define TEST_UID_ONE (uid_t)500 +#define TEST_GID_ONE (gid_t)500 +#define TEST_UID_TWO (uid_t)501 +#define TEST_GID_TWO (gid_t)501 + +struct file_description { + char *fd_name; + uid_t fd_owner; + gid_t fd_group; + mode_t fd_mode; +}; + +static struct file_description fd_list[] = { +{"test1", ROOT_UID, WHEEL_GID, 0400}, +{"test2", TEST_UID_ONE, WHEEL_GID,0400}, +{"test3", TEST_UID_TWO, WHEEL_GID, 0400}, +{"test4", ROOT_UID, WHEEL_GID, 0040}, +{"test5", ROOT_UID, TEST_GID_ONE, 0040}, +{"test6", ROOT_UID, TEST_GID_TWO, 0040}}; + +static int fd_list_count = sizeof(fd_list) / + sizeof(struct file_description); + +int +setup(void) +{ + int i, error; + + for (i = 0; i < fd_list_count; i++) { + error = open(fd_list[i].fd_name, O_CREAT | O_EXCL, + fd_list[i].fd_mode); + if (error == -1) { + perror("open"); + return (error); + } + close(error); + error = chown(fd_list[i].fd_name, fd_list[i].fd_owner, + fd_list[i].fd_group); + if (error) { + perror("chown"); + return (error); + } + } + return (0); +} + +int +restoreprivilege(void) +{ + int error; + + error = setreuid(ROOT_UID, ROOT_UID); + if (error) + return (error); + + error = setregid(WHEEL_GID, WHEEL_GID); + if (error) + return (error); + + return (0); +} + +int +reportprivilege(char *message) +{ + uid_t euid, ruid, suid; + gid_t egid, rgid, sgid; + int error; + + error = getresuid(&ruid, &euid, &suid); + if (error) { + perror("getresuid"); + return (error); + } + + error = getresgid(&rgid, &egid, &sgid); + if (error) { + perror("getresgid"); + return (error); + } + + if (message) + printf("%s: ", message); + printf("ruid: %d, euid: %d, suid: %d, ", ruid, euid, suid); + printf("rgid: %d, egid: %d, sgid: %d\n", rgid, egid, sgid); + + return (0); +} + +int +cleanup(void) +{ + int i, error; + + error = restoreprivilege(); + if (error) { + perror("restoreprivilege"); + return (error); + } + + for (i = 0; i < fd_list_count; i++) { + error = unlink(fd_list[i].fd_name); + if (error) + return (error); + } + + return (0); +} + +int +main(int argc, char *argv[]) +{ + int error, errorseen; + + if (geteuid() != 0) { + fprintf(stderr, "testaccess must run as root.\n"); + exit (EXIT_FAILURE); + } + + error = setup(); + if (error) { + cleanup(); + exit (EXIT_FAILURE); + } + + /* Make sure saved uid is set appropriately. */ + error = setresuid(ROOT_UID, ROOT_UID, ROOT_UID); + if (error) { + perror("setresuid"); + cleanup(); + } + + /* Clear out additional groups. */ + error = setgroups(0, NULL); + if (error) { + perror("setgroups"); + cleanup(); + } + + /* Make sure saved gid is set appropriately. */ + error = setresgid(WHEEL_GID, WHEEL_GID, WHEEL_GID); + if (error) { + perror("setresgid"); + cleanup(); + } + + /* + * UID-only tests. + */ + + /* Check that saved uid is not used */ + error = setresuid(TEST_UID_ONE, TEST_UID_ONE, ROOT_UID); + if (error) { + perror("setresuid.1"); + cleanup(); + exit (EXIT_FAILURE); + } + + errorseen = 0; + + error = access("test1", R_OK); + if (!error) { + fprintf(stderr, "saved uid used instead of real uid\n"); + errorseen++; + } + + error = restoreprivilege(); + if (error) { + perror("restoreprivilege"); + cleanup(); + exit (EXIT_FAILURE); + } + + error = setresuid(TEST_UID_ONE, TEST_UID_TWO, ROOT_UID); + if (error) { + perror("setresid.2"); + cleanup(); + exit (EXIT_FAILURE); + } + + /* Check that the real uid is used, not the effective uid */ + error = access("test2", R_OK); + if (error) { + fprintf(stderr, "Effective uid was used instead of real uid in" + " access().\n"); + errorseen++; + } + + /* Check that the real uid is used, not the effective uid */ + error = access("test3", R_OK); + if (!error) { + fprintf(stderr, "Effective uid was used instead of real uid in" + " access().\n"); + errorseen++; + } + + error = restoreprivilege(); + if (error) { + perror("restoreprivilege"); + cleanup(); + exit (EXIT_FAILURE); + } + + error = setresgid(TEST_GID_ONE, TEST_GID_TWO, WHEEL_GID); + if (error) { + perror("setresgid.1"); + cleanup(); + exit (EXIT_FAILURE); + } + + /* Set non-root effective uid to avoid excess privilege. */ + error = setresuid(TEST_UID_ONE, TEST_UID_ONE, ROOT_UID); + if (error) { + perror("setresuid.3"); + cleanup(); + exit (EXIT_FAILURE); + } + + /* Check that the saved gid is not used */ + error = access("test4", R_OK); + if (!error) { + fprintf(stderr, "saved gid used instead of real gid\n"); + } + + /* Check that the real gid is used, not the effective gid */ + error = access("test5", R_OK); + if (error) { + fprintf(stderr, "Effective gid was used instead of real gid in" + " access().\n"); + errorseen++; + } + + /* Check that the real gid is used, not the effective gid */ + error = access("test6", R_OK); + if (!error) { + fprintf(stderr, "Effective gid was used instead of real gid in" + " access().\n"); + errorseen++; + } + + fprintf(stderr, "%d errors seen.\n", errorseen); + + /* + * All tests done, restore and clean up + */ + + error = cleanup(); + if (error) { + perror("cleanup"); + exit (EXIT_FAILURE); + } + + exit (EXIT_SUCCESS); +} diff --git a/regress/sys/kern/open/Makefile b/regress/sys/kern/open/Makefile new file mode 100644 index 0000000..95619a4 --- /dev/null +++ b/regress/sys/kern/open/Makefile @@ -0,0 +1,14 @@ +PROG= open + +run-regress-${PROG}: ${PROG} + dd if=/dev/zero of=${.CURDIR}/fakeobj bs=512 count=4k + vnconfig svnd0 ${.CURDIR}/fakeobj + newfs -O 2 /dev/rsvnd0c + tunefs -a set /dev/rsvnd0c + mount /dev/svnd0c /mnt + ./${PROG} + umount /mnt + vnconfig -u svnd0 + rm -f ${.CURDIR}/fakeobj + +.include diff --git a/regress/sys/kern/open/open.c b/regress/sys/kern/open/open.c new file mode 100644 index 0000000..e5dec94 --- /dev/null +++ b/regress/sys/kern/open/open.c @@ -0,0 +1,1096 @@ +/* + * Copyright (c) 2008 Robert N. M. Watson + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: open_to_operation.c,v 1.1 2008/02/14 20:57:38 rwatson Exp $ + */ + +/* + * This regression test attempts to confirm that the flags used at open-time + * for a file descriptor properly limit system calls that should be affected + * by those flags. Currently: + * + * System call Policy Tested + * __acl_aclcheck_fd(2) any no + * __acl_delete_fd(2) any no + * __acl_get_fd(2) any no + * __acl_set_fd(2) any no + * dup(2) any yes + * dup2(2) any yes + * extattr_delete_fd(2) O_WRONLY or O_RDWR no + * extattr_get_fd(2) O_RDONLY or O_RDWR no + * extattr_list_fd(2) O_RDONLY or O_RDWR no + * extattr_set_fd(2) O_WRONLY or O_RDWR no + * fchdir(2) any directory yes + * fchflags(2) any yes + * fchmod(2) any yes + * fchown(2) any yes + * flock(2) any yes + * fpathconf(2) any yes + * fstat(2) any yes + * fstatfs(2) any yes + * fsync(2) any yes + * ftruncate(2) O_WRONLY or O_RDWR yes + * futimes(2) any yes + * lseek(2) any yes + * mmap(2) PROT_READ O_RDONLY or O_RDWR yes + * mmap(2) PROT_WRITE O_WRONLY or O_RDWR yes + * mmap(2) PROT_WRITE + MAP_PRIV O_RDONLY or O_RDWR yes + * mmap(2) PROT_EXEC O_RDONLY or O_RDWR yes + * pread(2) O_RDONLY or O_RDWR yes + * preadv(2) O_RDONLY or O_RDWR yes + * pwrite(2) O_WRONLY or O_RDWR yes + * pwritev(2) O_WRONLY or O_RDWR yes + * read(2) O_RDONLY or O_RDWR yes + * readv(2) O_RDONLY or O_RDWR yes + * write(2) O_WRONLY or O_RDWR yes + * writev(2) O_WRONLY or O_RDWR yes + * + * These checks do not verify that original permissions would allow the + * operation or that open is properly impacted by permissions, just that once + * a file descriptor is held, open-time limitations are implemented. + * + * We do, however, test that directories cannot be opened as writable. + * + * XXXRW: Arguably we should also test combinations of bits to mmap(2). + * + * XXXRW: Should verify mprotect() remapping limits. + * + * XXXRW: kqueue(2)/kevent(2), poll(2), select(2) + * + * XXXRW: __mac*(2) + * + * XXXRW: message queue and shared memory fds? + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define PERM_FILE 0644 /* Allow read, write. Someday exec? */ +#define PERM_DIR 0755 /* Allow read, write, exec. */ + +/* + * Modes to try all tests with. Don't try O_RDONLY with O_TRUNC, as the results + * are undefined (in OpenBSD, open() fails with EINVAL). + */ +static const int file_modes[] = { O_RDONLY, O_WRONLY, O_RDWR, + O_WRONLY | O_TRUNC, O_RDWR | O_TRUNC }; +static const int file_modes_count = sizeof(file_modes) / sizeof(int); + +static const int dir_modes[] = { O_RDONLY }; +static const int dir_modes_count = sizeof(dir_modes) / sizeof(int); + +static int testnum; + +static void +ok_mode(const char *testname, const char *comment, int mode) +{ + + testnum++; + if (comment == NULL) + printf("ok %d - %s # mode 0x%x\n", testnum, testname, mode); + else + printf("ok %d - %s # mode 0x%x - %s\n", testnum, testname, + mode, comment); +} + +static void +notok_mode(const char *testname, const char *comment, int mode) +{ + + testnum++; + if (comment == NULL) + printf("not ok %d - %s # mode 0x%x\n", testnum, testname, + mode); + else + printf("not ok %d - %s # mode 0x%x - %s\n", testnum, testname, + mode, comment); +} + +/* + * Before we get started, confirm that we can't open directories writable. + */ +static void +try_directory_open(const char *testname, const char *directory, + int mode, int expected_errno) +{ + int dfd; + + dfd = open(directory, mode); + if (dfd >= 0) { + if (expected_errno) + notok_mode(testname, "opened", mode); + else + ok_mode(testname, NULL, mode); + close(dfd); + } else { + if (expected_errno && expected_errno == expected_errno) + ok_mode(testname, NULL, mode); + else if (expected_errno) + notok_mode(testname, "wrong errno", mode); + else + notok_mode(testname, "failed", mode); + } +} + +static void +check_directory_open_modes(const char *directory, const int *modes, + int modes_count) +{ + int expected_errno, i, mode; + + /* + * Directories should only open with O_RDONLY. Notice that we use + * file_modes and not dirmodes. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + if (mode == O_RDONLY) + expected_errno = 0; + else + expected_errno = EISDIR; + try_directory_open(__func__, directory, mode, + expected_errno); + } +} + +static void +check_dup(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int dfd, fd, i, mode; + + /* + * dup() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + dfd = dup(fd); + if (dfd >= 0) { + ok_mode(testname, NULL, mode); + close(dfd); + } else + notok_mode(testname, NULL, mode); + close(fd); + } +} + +static void +check_dup2(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int dfd, fd, i, mode; + + /* + * dup2() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + dfd = dup2(fd, 127); /* Arbitrary but high number. */ + if (dfd >= 0) { + ok_mode(testname, NULL, mode); + close(dfd); + } else + notok_mode(testname, NULL, mode); + close(fd); + } +} + +static void +check_fchdir(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * fchdir() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fchdir(fd) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fchflags(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * fchflags() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fchflags(fd, UF_NODUMP) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fchmod(const char *testname, const char *path, int setmode, + const int *modes, int modes_count) +{ + int fd, i, mode; + + /* + * fchmod() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fchmod(fd, setmode) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fchown(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * fchown() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fchown(fd, -1, -1) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_flock(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * flock() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (flock(fd, LOCK_EX) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fpathconf(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + long l; + + /* + * fpathconf() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + l = fpathconf(fd, _PC_NAME_MAX); + if (l >= 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fstat(const char *testname, const char *path, const int *modes, + int modes_count) +{ + struct stat sb; + int fd, i, mode; + + /* + * fstat() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fstat(fd, &sb) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fstatfs(const char *testname, const char *path, const int *modes, + int modes_count) +{ + struct statfs statfs; + int fd, i, mode; + + /* + * fstatfs() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fstatfs(fd, &statfs) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_fsync(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * fstatfs() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fsync(fd) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_ftruncate(const char *testname, const char *path, const int *modes, + int modes_count) +{ + struct stat sb; + int fd, i, mode; + + /* + * ftruncate() should work as long as long as (mode & O_ACCMODE) is + * O_RDWR or O_WRONLY. + * + * Directories should never be writable, so this test should always + * pass for directories... + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + notok_mode(testname, "truncate1 skipped", mode); + notok_mode(testname, "truncate2 skipped", mode); + notok_mode(testname, "truncate3 skipped", mode); + continue; + } + if (fstat(fd, &sb) < 0) { + notok_mode(testname, "fstat", mode); + notok_mode(testname, "truncate1 skipped", mode); + notok_mode(testname, "truncate2 skipped", mode); + notok_mode(testname, "truncate3 skipped", mode); + close(fd); + continue; + } + ok_mode(testname, "setup", mode); + + /* Truncate to grow file. */ + if (ftruncate(fd, sb.st_size + 1) == 0) { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) + ok_mode(testname, "truncate1 succeeded", + mode); + else { + notok_mode(testname, "truncate1 succeeded", + mode); + notok_mode(testname, "truncate2 skipped", + mode); + notok_mode(testname, "truncate3 skipped", + mode); + close(fd); + continue; + } + } else { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) { + notok_mode(testname, "truncate1 failed", + mode); + notok_mode(testname, "truncate2 skipped", + mode); + notok_mode(testname, "truncate3 skipped", + mode); + close(fd); + continue; + } else + ok_mode(testname, "truncate1 failed", mode); + } + + /* Truncate to same size. */ + if (ftruncate(fd, sb.st_size + 1) == 0) { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) + ok_mode(testname, "truncate2 succeeded", + mode); + else { + notok_mode(testname, "truncate2 succeeded", + mode); + notok_mode(testname, "truncate3 skipped", + mode); + close(fd); + continue; + } + } else { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) { + notok_mode(testname, "truncate2 failed", + mode); + notok_mode(testname, "truncate3 skipped", + mode); + close(fd); + continue; + } else + ok_mode(testname, "truncate2 failed", mode); + } + + /* Truncate to shrink. */ + if (ftruncate(fd, sb.st_size) == 0) { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) + ok_mode(testname, "truncate3 succeeded", + mode); + else + notok_mode(testname, "truncate3 succeeded", + mode); + } else { + if (((mode & O_ACCMODE) == O_WRONLY) || + ((mode & O_ACCMODE) == O_RDWR)) + notok_mode(testname, "truncate3 failed", + mode); + else + ok_mode(testname, "truncate3 failed", mode); + } + close(fd); + } +} + +static void +check_futimes(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * futimes() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (futimes(fd, NULL) == 0) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +static void +check_lseek(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + + /* + * lseek() should work regardless of open mode. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (lseek(fd, 100, SEEK_SET) == 100) + ok_mode(testname, NULL, mode); + else + notok_mode(testname, "failed", mode); + close(fd); + } +} + +/* + * Various functions write, so just make write-like wrappers for them. + */ +typedef ssize_t (*write_fn)(int d, const void *buf, size_t nbytes); + +static ssize_t +writev_wrapper(int d, const void *buf, size_t nbytes) +{ + struct iovec iov; + + iov.iov_base = (void *)buf; + iov.iov_len = nbytes; + return (writev(d, &iov, 1)); +} + +static ssize_t +pwrite_wrapper(int d, const void *buf, size_t nbytes) +{ + + return (pwrite(d, buf, nbytes, 0)); +} + +static ssize_t +pwritev_wrapper(int d, const void *buf, size_t nbytes) +{ + struct iovec iov; + + iov.iov_base = (void *)buf; + iov.iov_len = nbytes; + return (pwritev(d, &iov, 1, 0)); +} + +static void +check_write(const char *testname, write_fn fn, const char *path, + const int *modes, int modes_count) +{ + int fd, i, mode; + char ch; + + /* + * write() should never succeed for directories, but especially + * because they can only be opened read-only. write() on files + * should succeed for O_WRONLY and O_RDWR descriptors. + */ + + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fn(fd, &ch, sizeof(ch)) < 0) { + if ((mode & O_ACCMODE) == O_WRONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "write failed", mode); + else + ok_mode(testname, "write failed", mode); + } else { + if (!((mode & O_ACCMODE) == O_WRONLY || + (mode & O_ACCMODE) == O_RDWR)) + notok_mode(testname, "write succeeded", mode); + else + ok_mode(testname, "write succeeded", mode); + } + close(fd); + } +} + +/* + * Various functions read, so just make read-like wrappers for them. + */ +typedef ssize_t (*read_fn)(int d, void *buf, size_t nbytes); + +static ssize_t +readv_wrapper(int d, void *buf, size_t nbytes) +{ + struct iovec iov; + + iov.iov_base = buf; + iov.iov_len = nbytes; + return (readv(d, &iov, 1)); +} + +static ssize_t +pread_wrapper(int d, void *buf, size_t nbytes) +{ + + return (pread(d, buf, nbytes, 0)); +} + +static ssize_t +preadv_wrapper(int d, void *buf, size_t nbytes) +{ + struct iovec iov; + + iov.iov_base = buf; + iov.iov_len = nbytes; + return (preadv(d, &iov, 1, 0)); +} + +static void +check_read(const char *testname, read_fn fn, const char *path, + const int *modes, int modes_count) +{ + int fd, i, mode; + char ch; + + /* + * read() should (generally) succeeded on directories. read() on + * files should succeed for O_RDONLY and O_RDWR descriptors. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + if (fn(fd, &ch, sizeof(ch)) < 0) { + if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "read failed", mode); + else + ok_mode(testname, "read failed", mode); + } else { + if (!((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR)) + notok_mode(testname, "read succeeded", mode); + else + ok_mode(testname, "read succeeded", mode); + } + close(fd); + } +} + +static void +check_mmap_read(const char *testname, const char *path, int isdir, + const int *modes, int modes_count) +{ + int fd, i, mode; + char *addr; + + /* + * mmap() read should fail for directories (ideally?) but succeed for + * O_RDONLY and O_RDWR file descriptors. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + addr = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd, + 0); + if (addr == MAP_FAILED) { + if (isdir) + ok_mode(testname, "mmap dir failed", mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "mmap file failed", + mode); + else + ok_mode(testname, "mmap file failed", mode); + } else { + if (isdir) + notok_mode(testname, "mmap dir succeeded", + mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + ok_mode(testname, "mmap file succeeded", + mode); + else + notok_mode(testname, "mmap file succeeded", + mode); + (void)munmap(addr, getpagesize()); + } + close(fd); + } +} + +static void +check_mmap_write(const char *testname, const char *path, const int *modes, + int modes_count) +{ + int fd, i, mode; + char *addr; + + /* + * mmap() will always fail for directories (ideally) as they are + * always open O_RDONLY. Check for O_WRONLY or O_RDWR to permit a + * write mapping. This variant does a MAP_SHARED mapping, but we + * are also interested in MAP_PRIVATE. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + addr = mmap(NULL, getpagesize(), PROT_WRITE, MAP_SHARED, fd, + 0); + if (addr == MAP_FAILED) { + if ((mode & O_ACCMODE) == O_WRONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "mmap failed", + mode); + else + ok_mode(testname, "mmap failed", mode); + } else { + if ((mode & O_ACCMODE) == O_WRONLY || + (mode & O_ACCMODE) == O_RDWR) + ok_mode(testname, "mmap succeeded", + mode); + else + notok_mode(testname, "mmap succeeded", mode); + (void)munmap(addr, getpagesize()); + } + close(fd); + } +} + +static void +check_mmap_exec(const char *testname, const char *path, int isdir, + const int *modes, int modes_count) +{ + int fd, i, mode; + char *addr; + + /* + * mmap() exec should fail for directories (ideally?) but succeed for + * O_RDONLY and O_RDWR file descriptors. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + addr = mmap(NULL, getpagesize(), PROT_EXEC, MAP_SHARED, fd, + 0); + if (addr == MAP_FAILED) { + if (isdir) + ok_mode(testname, "mmap dir failed", mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "mmap file failed", + mode); + else + ok_mode(testname, "mmap file failed", mode); + } else { + if (isdir) + notok_mode(testname, "mmap dir succeeded", + mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + ok_mode(testname, "mmap file succeeded", + mode); + else + notok_mode(testname, "mmap file succeeded", + mode); + (void)munmap(addr, getpagesize()); + } + close(fd); + } +} + +static void +check_mmap_write_private(const char *testname, const char *path, int isdir, + const int *modes, int modes_count) +{ + int fd, i, mode; + char *addr; + + /* + * mmap() write private should succeed for readable descriptors + * except for directories. + */ + for (i = 0; i < modes_count; i++) { + mode = modes[i]; + fd = open(path, mode); + if (fd < 0) { + notok_mode(testname, "open", mode); + continue; + } + addr = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, + MAP_PRIVATE, fd, 0); + if (addr == MAP_FAILED) { + if (isdir) + ok_mode(testname, "mmap dir failed", mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + notok_mode(testname, "mmap file failed", + mode); + else + ok_mode(testname, "mmap file failed", mode); + } else { + if (isdir) + notok_mode(testname, "mmap dir succeeded", + mode); + else if ((mode & O_ACCMODE) == O_RDONLY || + (mode & O_ACCMODE) == O_RDWR) + ok_mode(testname, "mmap file succeeded", + mode); + else + notok_mode(testname, "mmap file succeeded", + mode); + (void)munmap(addr, getpagesize()); + } + close(fd); + } +} + +int +main(int argc, char *argv[]) +{ + char dir_path[PATH_MAX], file_path[PATH_MAX]; + int fd; + + strlcpy(dir_path, "/mnt/open-dir.XXXXXXXXXXX", sizeof(dir_path)); + if (mkdtemp(dir_path) == NULL) + err(-1, "mkdtemp"); + if (chmod(dir_path, PERM_DIR) < 0) { + warn("chmod %s", dir_path); + (void)rmdir(dir_path); + exit(-1); + } + strlcpy(file_path, "/mnt/open-file.XXXXXXXXXXX", sizeof(file_path)); + fd = mkstemp(file_path); + if (fd < 0) { + warn("mkstemp"); + (void)rmdir(dir_path); + exit(-1); + } + close(fd); + if (chmod(file_path, PERM_FILE) < 0) { + warn("chmod %s", file_path); + (void)unlink(file_path); + (void)rmdir(dir_path); + exit(-1); + } + check_directory_open_modes(dir_path, file_modes, file_modes_count); + + check_dup("dup_dir", dir_path, dir_modes, dir_modes_count); + check_dup("dup_file", file_path, file_modes, file_modes_count); + + check_dup2("dup2_dir", dir_path, dir_modes, dir_modes_count); + check_dup2("dup2_file", file_path, file_modes, + file_modes_count); + + check_fchdir("fchdir", dir_path, dir_modes, dir_modes_count); + + check_fchflags("fchflags_dir", dir_path, dir_modes, + dir_modes_count); + check_fchflags("fchflags_file", file_path, file_modes, + file_modes_count); + + check_fchmod("fchmod_dir", dir_path, PERM_DIR, dir_modes, + dir_modes_count); + check_fchmod("fchmod_file", file_path, PERM_FILE, file_modes, + file_modes_count); + + check_fchown("fchown_dir", dir_path, dir_modes, + dir_modes_count); + check_fchown("fchown_file", file_path, file_modes, + file_modes_count); + + check_flock("flock_dir", dir_path, dir_modes, dir_modes_count); + check_flock("flock_file", file_path, file_modes, + file_modes_count); + + check_fpathconf("fpathconf_dir", dir_path, dir_modes, + dir_modes_count); + check_fpathconf("fpathconf_file", file_path, file_modes, + file_modes_count); + + check_fstat("fstat_dir", dir_path, dir_modes, dir_modes_count); + check_fstat("fstat_file", file_path, file_modes, + file_modes_count); + + check_fstatfs("fstatfs_dir", dir_path, dir_modes, + dir_modes_count); + check_fstatfs("fstatfs_file", file_path, file_modes, + file_modes_count); + + check_fsync("fsync_dir", dir_path, dir_modes, dir_modes_count); + check_fsync("fsync_file", file_path, file_modes, + file_modes_count); + + check_ftruncate("ftruncate_dir", dir_path, dir_modes, + dir_modes_count); + check_ftruncate("ftruncate_file", file_path, file_modes, + file_modes_count); + + check_futimes("futimes_dir", dir_path, dir_modes, + dir_modes_count); + check_futimes("futimes_file", file_path, file_modes, + file_modes_count); + + check_lseek("lseek_dir", dir_path, dir_modes, dir_modes_count); + check_lseek("lseek_file", file_path, file_modes, + file_modes_count); + + check_write("write_dir", write, dir_path, dir_modes, + dir_modes_count); + check_write("write_file", write, file_path, file_modes, + file_modes_count); + + check_write("writev_dir", writev_wrapper, dir_path, dir_modes, + dir_modes_count); + check_write("writev_file", writev_wrapper, file_path, + file_modes, file_modes_count); + + check_write("pwrite_dir", pwrite_wrapper, dir_path, dir_modes, + dir_modes_count); + check_write("pwrite_file", pwrite_wrapper, file_path, + file_modes, file_modes_count); + + check_write("pwritev_dir", pwritev_wrapper, dir_path, + dir_modes, dir_modes_count); + check_write("pwritev_file", pwritev_wrapper, file_path, + file_modes, file_modes_count); + + check_read("read_dir", read, dir_path, dir_modes, + dir_modes_count); + check_read("read_file", read, file_path, file_modes, + file_modes_count); + + check_read("readv_dir", readv_wrapper, dir_path, dir_modes, + dir_modes_count); + check_read("readv_file", readv_wrapper, file_path, + file_modes, file_modes_count); + + check_read("pread_dir", pread_wrapper, dir_path, dir_modes, + dir_modes_count); + check_read("pread_file", pread_wrapper, file_path, + file_modes, file_modes_count); + + check_read("preadv_dir", preadv_wrapper, dir_path, + dir_modes, dir_modes_count); + check_read("preadv_file", preadv_wrapper, file_path, + file_modes, file_modes_count); + + check_mmap_read("mmap_read_dir", dir_path, 1, dir_modes, + dir_modes_count); + check_mmap_read("mmap_read_file", file_path, 0, file_modes, + file_modes_count); + + check_mmap_write("mmap_write_dir", dir_path, dir_modes, + dir_modes_count); + check_mmap_write("mmap_write_file", file_path, file_modes, + file_modes_count); + + check_mmap_exec("mmap_exec_dir", dir_path, 1, dir_modes, + dir_modes_count); + check_mmap_exec("mmap_exec_file", file_path, 0, file_modes, + file_modes_count); + + check_mmap_write_private("mmap_write_private_dir", dir_path, 1, + dir_modes, dir_modes_count); + check_mmap_write_private("mmap_write_private_file", file_path, + 0, file_modes, file_modes_count); + + (void)unlink(file_path); + (void)rmdir(dir_path); + exit(0); +} diff --git a/sbin/dump/dump.h b/sbin/dump/dump.h index 772604f..c641433 100644 --- a/sbin/dump/dump.h +++ b/sbin/dump/dump.h @@ -83,6 +83,11 @@ long dev_bsize; /* block size of underlying disk device */ int dev_bshift; /* log2(dev_bsize) */ int tp_bshift; /* log2(TP_BSIZE) */ +union dinode { + struct ufs1_dinode dp1; + struct ufs2_dinode dp2; +}; + /* operator interface functions */ void broadcast(char *message); time_t do_stats(void); @@ -105,7 +110,8 @@ int mapdirs(ino_t maxino, off_t *tapesize); /* file dumping routines */ void ufs1_blksout(int32_t *blkp, int frags, ino_t ino); -void ufs2_blksout(daddr64_t *blkp, int frags, ino_t ino); +void ufs2_blksout(union dinode *dp, daddr64_t *blkp, int frags, ino_t ino, + int); void bread(daddr64_t blkno, char *buf, int size); void dumpino(union dinode *dp, ino_t ino); void dumpmap(char *map, int type, ino_t ino); diff --git a/sbin/dump/traverse.c b/sbin/dump/traverse.c index f49d857..87c9467 100644 --- a/sbin/dump/traverse.c +++ b/sbin/dump/traverse.c @@ -57,10 +57,6 @@ static const char rcsid[] = "$OpenBSD: otto $"; #include "dump.h" -union dinode { - struct ufs1_dinode dp1; - struct ufs2_dinode dp2; -}; #define DIP(dp, field) \ ((sblock->fs_magic == FS_UFS1_MAGIC) ? \ (dp)->dp1.field : (dp)->dp2.field) @@ -69,8 +65,11 @@ union dinode { #define HASSUBDIRS 0x2 static int dirindir(ino_t ino, daddr64_t blkno, int level, off_t *size); -static void dmpindir(ino_t ino, daddr64_t blk, int level, off_t *size); +static void dmpindir(union dinode *dp, ino_t ino, daddr64_t blk, int level, + off_t *size); static int searchdir(ino_t ino, daddr64_t blkno, long size, off_t filesize); +static int appendextdata(union dinode *dp); +static void writeextdata(union dinode *dp, ino_t ino, int added); /* * This is an estimation of the number of TP_BSIZE blocks in the file. @@ -466,7 +465,7 @@ searchdir(ino_t ino, daddr64_t blkno, long size, off_t filesize) void dumpino(union dinode *dp, ino_t ino) { - int ind_level, cnt; + int ind_level, cnt, last, added; off_t size; char buf[TP_BSIZE]; @@ -475,9 +474,10 @@ dumpino(union dinode *dp, ino_t ino) dumpmap(dumpinomap, TS_BITS, ino); } CLRINO(ino, dumpinomap); - if (sblock->fs_magic == FS_UFS1_MAGIC) { + if (sblock->fs_magic == FS_UFS1_MAGIC) { spcl.c_mode = dp->dp1.di_mode; spcl.c_size = dp->dp1.di_size; + spcl.c_extsize = 0; spcl.c_old_atime = (time_t)dp->dp1.di_atime; spcl.c_atime = dp->dp1.di_atime; spcl.c_atimensec = dp->dp1.di_atimensec; @@ -493,6 +493,7 @@ dumpino(union dinode *dp, ino_t ino) } else { spcl.c_mode = dp->dp2.di_mode; spcl.c_size = dp->dp2.di_size; + spcl.c_extsize = dp->dp2.di_extsize; spcl.c_atime = dp->dp2.di_atime; spcl.c_atimensec = dp->dp2.di_atimensec; spcl.c_mtime = dp->dp2.di_mtime; @@ -529,6 +530,7 @@ dumpino(union dinode *dp, ino_t ino) spcl.c_addr[0] = 1; spcl.c_count = 1; + added = appendextdata(dp); writeheader(ino); if (sblock->fs_magic == FS_UFS1_MAGIC) shortlink = dp->dp1.di_shortlink; @@ -537,6 +539,7 @@ dumpino(union dinode *dp, ino_t ino) memcpy(buf, shortlink, DIP(dp, di_size)); buf[DIP(dp, di_size)] = '\0'; writerec(buf, 0); + writeextdata(dp, ino, added); return; } /* FALLTHROUGH */ @@ -551,7 +554,9 @@ dumpino(union dinode *dp, ino_t ino) case IFSOCK: case IFCHR: case IFBLK: + added = appendextdata(dp); writeheader(ino); + writeextdata(dp, ino, added); return; default: @@ -559,18 +564,21 @@ dumpino(union dinode *dp, ino_t ino) DIP(dp, di_mode) & IFMT); return; } - if (DIP(dp, di_size) > NDADDR * sblock->fs_bsize) + if (DIP(dp, di_size) > NDADDR * sblock->fs_bsize) { cnt = NDADDR * sblock->fs_frag; - else + last = 0; + } else { cnt = howmany(DIP(dp, di_size), sblock->fs_fsize); + last = 1; + } if (sblock->fs_magic == FS_UFS1_MAGIC) ufs1_blksout(&dp->dp1.di_db[0], cnt, ino); else - ufs2_blksout(&dp->dp2.di_db[0], cnt, ino); + ufs2_blksout(dp, &dp->dp2.di_db[0], cnt, ino, last); if ((size = DIP(dp, di_size) - NDADDR * sblock->fs_bsize) <= 0) return; for (ind_level = 0; ind_level < NIADDR; ind_level++) { - dmpindir(ino, DIP(dp, di_ib[ind_level]), ind_level, &size); + dmpindir(dp, ino, DIP(dp, di_ib[ind_level]), ind_level, &size); if (size <= 0) return; } @@ -580,35 +588,41 @@ dumpino(union dinode *dp, ino_t ino) * Read indirect blocks, and pass the data blocks to be dumped. */ static void -dmpindir(ino_t ino, daddr64_t blk, int ind_level, off_t *size) +dmpindir(union dinode *dp, ino_t ino, daddr64_t blk, int ind_level, + off_t *size) { - int i, cnt; - char idblk[MAXBSIZE]; + union { + daddr_t ufs1[MAXBSIZE / sizeof(daddr_t)]; + daddr64_t ufs2[MAXBSIZE / sizeof(daddr64_t)]; + } idblk; + int i, cnt, last; if (blk != 0) - bread(fsbtodb(sblock, blk), idblk, (int) sblock->fs_bsize); + bread(fsbtodb(sblock, blk), (char *)&idblk, + (int)sblock->fs_bsize); else - memset(idblk, 0, (int)sblock->fs_bsize); + memset(&idblk, 0, sblock->fs_bsize); if (ind_level <= 0) { - if (*size < NINDIR(sblock) * sblock->fs_bsize) - cnt = howmany(*size, sblock->fs_fsize); - else + if (*size > NINDIR(sblock) * sblock->fs_bsize) { cnt = NINDIR(sblock) * sblock->fs_frag; + last = 0; + } else { + cnt = howmany(*size, sblock->fs_fsize); + last = 1; + } *size -= NINDIR(sblock) * sblock->fs_bsize; if (sblock->fs_magic == FS_UFS1_MAGIC) - ufs1_blksout((int32_t *)idblk, cnt, ino); + ufs1_blksout(idblk.ufs1, cnt, ino); else - ufs2_blksout((int64_t *)idblk, cnt, ino); + ufs2_blksout(dp, idblk.ufs2, cnt, ino, last); return; } ind_level--; for (i = 0; i < NINDIR(sblock); i++) { if (sblock->fs_magic == FS_UFS1_MAGIC) - dmpindir(ino, ((int32_t *)idblk)[i], ind_level, - size); + dmpindir(dp, ino, idblk.ufs1[i], ind_level, size); else - dmpindir(ino, ((int64_t *)idblk)[i], ind_level, - size); + dmpindir(dp, ino, idblk.ufs2[i], ind_level, size); if (*size <= 0) return; } @@ -653,12 +667,24 @@ ufs1_blksout(int32_t *blkp, int frags, ino_t ino) * Collect up the data into tape record sized buffers and output them. */ void -ufs2_blksout(daddr64_t *blkp, int frags, ino_t ino) +ufs2_blksout(union dinode *dp, daddr64_t *blkp, int frags, ino_t ino, + int last) { daddr64_t *bp; - int i, j, count, blks, tbperdb; + int i, j, count, resid, blks, tbperdb, added; + static int writingextdata = 0; + /* + * Calculate the number of TP_BSIZE blocks to be dumped. + * For filesystems with a fragment size bigger than TP_BSIZE, + * only part of the final fragment may need to be dumped. + */ blks = howmany(frags * sblock->fs_fsize, TP_BSIZE); + if (last) { + resid = howmany(fragoff(sblock, dp->dp2.di_size), TP_BSIZE); + if (resid > 0) + blks -= howmany(sblock->fs_fsize, TP_BSIZE) - resid; + } tbperdb = sblock->fs_bsize >> tp_bshift; for (i = 0; i < blks; i += TP_NINDIR) { if (i + TP_NINDIR > blks) @@ -671,6 +697,8 @@ ufs2_blksout(daddr64_t *blkp, int frags, ino_t ino) else spcl.c_addr[j - i] = 0; spcl.c_count = count - i; + if (last && count == blks && !writingextdata) + added = appendextdata(dp); writeheader(ino); bp = &blkp[i / tbperdb]; for (j = i; j < count; j += tbperdb, bp++) @@ -681,7 +709,122 @@ ufs2_blksout(daddr64_t *blkp, int frags, ino_t ino) dumpblock(*bp, (count - j) * TP_BSIZE); } spcl.c_type = TS_ADDR; + spcl.c_count = 0; + if (last && count == blks && !writingextdata) { + writingextdata = 1; + writeextdata(dp, ino, added); + writingextdata = 0; + } + } +} + +/* + * If there is room in the current block for the extended attributes + * as well as the file data, update the header to reflect the added + * attribute data at the end. Attributes are placed at the end so that + * old versions of restore will correctly restore the file and simply + * discard the extra data at the end that it does not understand. + * The attribute data is dumped following the file data by the + * writeextdata() function (below). + */ +static int +appendextdata(union dinode *dp) +{ + int i, blks, tbperdb; + + /* + * If no extended attributes, there is nothing to do. + */ + if (spcl.c_extsize == 0) + return (0); + /* + * If there is not enough room at the end of this block + * to add the extended attributes, then rather than putting + * part of them here, we simply push them entirely into a + * new block rather than putting some here and some later. + */ + if (spcl.c_extsize > NXADDR * sblock->fs_bsize) + blks = howmany(NXADDR * sblock->fs_bsize, TP_BSIZE); + else + blks = howmany(spcl.c_extsize, TP_BSIZE); + if (spcl.c_count + blks > TP_NINDIR) + return (0); + /* + * Update the block map in the header to indicate the added + * extended attribute. They will be appended after the file + * data by the writeextdata() routine. + */ + tbperdb = sblock->fs_bsize >> tp_bshift; + for (i = 0; i < blks; i++) + if (&dp->dp2.di_extb[i / tbperdb] != 0) + spcl.c_addr[spcl.c_count + i] = 1; + else + spcl.c_addr[spcl.c_count + i] = 0; + spcl.c_count += blks; + return (blks); +} + +/* + * Dump the extended attribute data. If there was room in the file + * header, then all we need to do is output the data blocks. If there + * was not room in the file header, then an additional TS_ADDR header + * is created to hold the attribute data. + */ +static void +writeextdata(union dinode *dp, ino_t ino, int added) +{ + int i, frags, blks, tbperdb, last; + daddr64_t *bp; + off_t size; + + /* + * If no extended attributes, there is nothing to do. + */ + if (spcl.c_extsize == 0) + return; + /* + * If there was no room in the file block for the attributes, + * dump them out in a new block, otherwise just dump the data. + */ + if (added == 0) { + if (spcl.c_extsize > NXADDR * sblock->fs_bsize) { + frags = NXADDR * sblock->fs_frag; + last = 0; + } else { + frags = howmany(spcl.c_extsize, sblock->fs_fsize); + last = 1; + } + ufs2_blksout(dp, &dp->dp2.di_extb[0], frags, ino, last); + } else { + if (spcl.c_extsize > NXADDR * sblock->fs_bsize) + blks = howmany(NXADDR * sblock->fs_bsize, TP_BSIZE); + else + blks = howmany(spcl.c_extsize, TP_BSIZE); + tbperdb = sblock->fs_bsize >> tp_bshift; + for (i = 0; i < blks; i += tbperdb) { + bp = &dp->dp2.di_extb[i / tbperdb]; + if (*bp != 0) { + if (i + tbperdb <= blks) + dumpblock(*bp, (int)sblock->fs_bsize); + else + dumpblock(*bp, (blks - i) * TP_BSIZE); + } + } + } + /* + * If an indirect block is added for extended attributes, then + * di_exti below should be changed to the structure element + * that references the extended attribute indirect block. This + * definition is here only to make it compile without complaint. + */ +#define di_exti di_spare[0] + /* + * If the extended attributes fall into an indirect block, + * dump it as well. + */ + if ((size = spcl.c_extsize - NXADDR * sblock->fs_bsize) > 0) + dmpindir(dp, ino, dp->dp2.di_exti, 0, &size); } /* diff --git a/sbin/dumpfs/dumpfs.c b/sbin/dumpfs/dumpfs.c index 2a24600..3c9ab82 100644 --- a/sbin/dumpfs/dumpfs.c +++ b/sbin/dumpfs/dumpfs.c @@ -284,6 +284,8 @@ dumpfs(int fd, const char *name) printf("unclean "); if (fsflags & FS_DOSOFTDEP) printf("soft-updates "); + if (fsflags & FS_ACLS) + printf("acls "); if (fsflags & FS_FLAGS_UPDATED) printf("updated "); #if 0 diff --git a/sbin/fsck_ffs/pass1.c b/sbin/fsck_ffs/pass1.c index 85d445f..aed7931 100644 --- a/sbin/fsck_ffs/pass1.c +++ b/sbin/fsck_ffs/pass1.c @@ -126,7 +126,7 @@ checkinode(ino_t inumber, struct inodesc *idesc) union dinode *dp; off_t kernmaxfilesize; struct zlncnt *zlnp; - int ndb, j; + int ndb, j, offset, ret; mode_t mode; char *symbuf; u_int64_t lndb; @@ -288,6 +288,23 @@ checkinode(ino_t inumber, struct inodesc *idesc) badblk = dupblk = 0; idesc->id_number = inumber; (void)ckinode(dp, idesc); + if (sblock.fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize > 0) { + ndb = howmany(dp->dp2.di_extsize, sblock.fs_bsize); + for (j = 0; j < NXADDR; j++) { + if (--ndb == 0 && + (offset = blkoff(&sblock, dp->dp2.di_extsize)) != 0) + idesc->id_numfrags = numfrags(&sblock, + fragroundup(&sblock, offset)); + else + idesc->id_numfrags = sblock.fs_frag; + if (dp->dp2.di_extb[j] == 0) + continue; + idesc->id_blkno = dp->dp2.di_extb[j]; + ret = (*idesc->id_func)(idesc); + if (ret & STOP) + break; + } + } idesc->id_entryno *= btodb(sblock.fs_fsize); if (DIP(dp, di_blocks) != idesc->id_entryno) { pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %d)", diff --git a/sbin/mount/mount.c b/sbin/mount/mount.c index 5a3d6f2..0549cee 100644 --- a/sbin/mount/mount.c +++ b/sbin/mount/mount.c @@ -90,6 +90,7 @@ static struct opt { const char *o_name; const char *o_optname; } optnames[] = { + { MNT_ACLS, 0, "acl", "acl" }, { MNT_ASYNC, 0, "asynchronous", "async" }, { MNT_DEFEXPORTED, 1, "exported to the world", "" }, { MNT_EXKERB, 1, "kerberos uid mapping", "" }, diff --git a/sbin/restore/dirs.c b/sbin/restore/dirs.c index 80c830f..2a3c623 100644 --- a/sbin/restore/dirs.c +++ b/sbin/restore/dirs.c @@ -89,6 +89,7 @@ struct modeinfo { uid_t uid; gid_t gid; u_int flags; + int extsize; }; /* @@ -128,6 +129,7 @@ static void flushent(void); static struct inotab *inotablookup(ino_t); static RST_DIR *opendirfile(const char *); static void putdir(char *, size_t); +static void putdirattrs(char *, size_t); static void putent(struct direct *); static void rst_seekdir(RST_DIR *, long, long); static long rst_telldir(RST_DIR *); @@ -196,7 +198,7 @@ extractdirs(int genmode) return; } itp = allocinotab(mf, &curfile, seekpt); - getfile(putdir, xtrnull); + getfile(putdir, putdirattrs, xtrnull); putent(&nulldir); flushent(); itp->t_size = seekpt - itp->t_seekpt; @@ -432,6 +434,16 @@ flushent(void) dirloc = 0; } +/* + * Save extended attributes for a directory entry to a file. + */ +static void +putdirattrs(char *buf, size_t size) +{ + if (mf != NULL) + (void) fwrite(buf, 1, size, mf); +} + static void dcvt(struct odirect *odp, struct direct *ndp) { @@ -578,7 +590,8 @@ setdirmodes(int flags) FILE *mf; struct modeinfo node; struct entry *ep; - char *cp; + char *cp, *buf; + int bufsize; Vprintf(stdout, "Set directory mode, owner, and times.\n"); if (command == 'r' || command == 'R') @@ -597,10 +610,27 @@ setdirmodes(int flags) return; } clearerr(mf); + bufsize = 0; for (;;) { (void)fread((char *)&node, 1, sizeof(struct modeinfo), mf); if (feof(mf)) break; + if (node.extsize > 0) { + if (bufsize < node.extsize) { + if (bufsize > 0) + free(buf); + if ((buf = malloc(node.extsize)) != 0) { + bufsize = node.extsize; + } else { + bufsize = 0; + } + } + if (bufsize >= node.extsize) { + (void) fread(buf, 1, node.extsize, mf); + } else { + (void) fseek(mf, node.extsize, SEEK_CUR); + } + } ep = lookupino(node.ino); if (command == 'i' || command == 'x') { if (ep == NULL) @@ -618,6 +648,16 @@ setdirmodes(int flags) } else { if (!Nflag) { cp = myname(ep); + if (node.extsize > 0) { + if (bufsize >= node.extsize) { + set_extattr_file(cp, buf, + node.extsize); + } else { + fprintf(stderr, "Cannot " + "restore extended " + "attributes for %s\n", cp); + } + } (void)chown(cp, node.uid, node.gid); (void)chmod(cp, node.mode); (void)chflags(cp, node.flags); @@ -627,6 +667,8 @@ setdirmodes(int flags) ep->e_flags &= ~NEW; } } + if (bufsize > 0) + free(buf); if (ferror(mf)) panic("error setting directory modes\n"); (void)fclose(mf); @@ -712,6 +754,7 @@ allocinotab(FILE *mf, struct context *ctxp, long seekpt) node.ctimep[0].tv_usec = ctxp->atime_nsec / 1000; node.ctimep[1].tv_sec = ctxp->birthtime_sec; node.ctimep[1].tv_usec = ctxp->birthtime_nsec / 1000; + node.extsize = ctxp->extsize; node.mode = ctxp->mode; node.flags = ctxp->file_flags; node.uid = ctxp->uid; diff --git a/sbin/restore/extattr.h b/sbin/restore/extattr.h new file mode 100644 index 0000000..c314712 --- /dev/null +++ b/sbin/restore/extattr.h @@ -0,0 +1,160 @@ +/*- + * Copyright (c) 1999-2001 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: src/sys/ufs/ufs/extattr.h,v 1.21 2007/03/06 08:13:20 mckusick Exp $ + */ +/* + * Developed by the TrustedBSD Project. + * Support for extended filesystem attributes. + */ + +#ifndef _UFS_UFS_EXTATTR_H_ +#define _UFS_UFS_EXTATTR_H_ + +#define UFS_EXTATTR_MAGIC 0x00b5d5ec +#define UFS_EXTATTR_VERSION 0x00000003 +#define UFS_EXTATTR_FSROOTSUBDIR ".attribute" +#define UFS_EXTATTR_SUBDIR_SYSTEM "system" +#define UFS_EXTATTR_SUBDIR_USER "user" +#define UFS_EXTATTR_MAXEXTATTRNAME 65 /* including null */ + +#define UFS_EXTATTR_ATTR_FLAG_INUSE 0x00000001 /* attr has been set */ +#define UFS_EXTATTR_PERM_KERNEL 0x00000000 +#define UFS_EXTATTR_PERM_ROOT 0x00000001 +#define UFS_EXTATTR_PERM_OWNER 0x00000002 +#define UFS_EXTATTR_PERM_ANYONE 0x00000003 + +#define UFS_EXTATTR_UEPM_INITIALIZED 0x00000001 +#define UFS_EXTATTR_UEPM_STARTED 0x00000002 + +#define UFS_EXTATTR_CMD_START 0x00000001 +#define UFS_EXTATTR_CMD_STOP 0x00000002 +#define UFS_EXTATTR_CMD_ENABLE 0x00000003 +#define UFS_EXTATTR_CMD_DISABLE 0x00000004 + +struct ufs_extattr_fileheader { + u_int uef_magic; /* magic number for sanity checking */ + u_int uef_version; /* version of attribute file */ + u_int uef_size; /* size of attributes, w/o header */ +}; + +struct ufs_extattr_header { + u_int ueh_flags; /* flags for attribute */ + u_int ueh_len; /* local defined length; <= uef_size */ + u_int32_t ueh_i_gen; /* generation number for sanity */ + /* data follows the header */ +}; + +/* + * This structure defines the required fields of an extended-attribute header. + */ +struct extattr { + int32_t ea_length; /* length of this attribute */ + int8_t ea_namespace; /* name space of this attribute */ + int8_t ea_contentpadlen; /* bytes of padding at end of attribute */ + int8_t ea_namelength; /* length of attribute name */ + char ea_name[1]; /* null-terminated attribute name */ + /* extended attribute content follows */ +}; + +/* + * These macros are used to access and manipulate an extended attribute: + * + * EXTATTR_NEXT(eap) returns a pointer to the next extended attribute + * following eap. + * EXTATTR_CONTENT(eap) returns a pointer to the extended attribute + * content referenced by eap. + * EXTATTR_CONTENT_SIZE(eap) returns the size of the extended attribute + * content referenced by eap. + * EXTATTR_SET_LENGTHS(eap, contentsize) called after initializing the + * attribute name to calculate and set the ea_length, ea_namelength, + * and ea_contentpadlen fields of the extended attribute structure. + */ +#define EXTATTR_NEXT(eap) \ + ((struct extattr *)(((void *)(eap)) + (eap)->ea_length)) +#define EXTATTR_CONTENT(eap) (((void *)(eap)) + EXTATTR_BASE_LENGTH(eap)) +#define EXTATTR_CONTENT_SIZE(eap) \ + ((eap)->ea_length - EXTATTR_BASE_LENGTH(eap) - (eap)->ea_contentpadlen) +#define EXTATTR_BASE_LENGTH(eap) \ + ((sizeof(struct extattr) + (eap)->ea_namelength + 7) & ~7) +#define EXTATTR_SET_LENGTHS(eap, contentsize) do { \ + KASSERT(((eap)->ea_name[0] != 0), \ + ("Must initialize name before setting lengths")); \ + (eap)->ea_namelength = strlen((eap)->ea_name); \ + (eap)->ea_contentpadlen = ((contentsize) % 8) ? \ + 8 - ((contentsize) % 8) : 0; \ + (eap)->ea_length = EXTATTR_BASE_LENGTH(eap) + \ + (contentsize) + (eap)->ea_contentpadlen; \ +} while (0) + +#ifdef _KERNEL + +#ifdef MALLOC_DECLARE +MALLOC_DECLARE(M_EXTATTR); +#endif + +struct vnode; +LIST_HEAD(ufs_extattr_list_head, ufs_extattr_list_entry); +struct ufs_extattr_list_entry { + LIST_ENTRY(ufs_extattr_list_entry) uele_entries; + struct ufs_extattr_fileheader uele_fileheader; + int uele_attrnamespace; + char uele_attrname[UFS_EXTATTR_MAXEXTATTRNAME]; + struct vnode *uele_backing_vnode; +}; + +struct lock; +struct ucred; +struct ufs_extattr_per_mount { + struct lock uepm_lock; + struct ufs_extattr_list_head uepm_list; + struct ucred *uepm_ucred; + int uepm_flags; +}; + +void ufs_extattr_uepm_init(struct ufs_extattr_per_mount *uepm); +void ufs_extattr_uepm_destroy(struct ufs_extattr_per_mount *uepm); +int ufs_extattr_start(struct mount *mp, struct thread *td); +int ufs_extattr_autostart(struct mount *mp, struct thread *td); +int ufs_extattr_stop(struct mount *mp, struct thread *td); +int ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename, + int attrnamespace, const char *attrname, struct thread *td); +int ufs_getextattr(struct vop_getextattr_args *ap); +int ufs_deleteextattr(struct vop_deleteextattr_args *ap); +int ufs_setextattr(struct vop_setextattr_args *ap); +void ufs_extattr_vnode_inactive(struct vnode *vp, struct thread *td); + +#else + +/* User-level definition of KASSERT for macros above */ +#define KASSERT(cond, str) do { \ + if (!(cond)) { printf("panic: "); printf(str); printf("\n"); exit(1); }\ +} while (0) + +#endif /* !_KERNEL */ + +#endif /* !_UFS_UFS_EXTATTR_H_ */ diff --git a/sbin/restore/extern.h b/sbin/restore/extern.h index 01b65af..2855f54 100644 --- a/sbin/restore/extern.h +++ b/sbin/restore/extern.h @@ -54,7 +54,8 @@ void freeentry(struct entry *); void freename(char *); int genliteraldir(char *, ino_t); char *gentempname(struct entry *); -void getfile(void (*)(char *, size_t), void (*)(char *, size_t)); +void getfile(void (*)(char *, size_t), void (*)(char *, size_t), + void (*)(char *, size_t)); void getvol(long); void initsymtable(char *); int inodetype(ino_t); @@ -86,6 +87,7 @@ struct direct *rst_readdir(RST_DIR *); void rst_closedir(RST_DIR *dirp); void runcmdshell(void); char *savename(char *); +void set_extattr_file(char *, void *, int); void setdirmodes(int); void setinput(char *); void setup(void); diff --git a/sbin/restore/restore.h b/sbin/restore/restore.h index d1ebf9c..b0b4aeb 100644 --- a/sbin/restore/restore.h +++ b/sbin/restore/restore.h @@ -118,6 +118,7 @@ struct context { int atime_nsec; /* access time nanoseconds */ int mtime_nsec; /* modified time nanoseconds */ int birthtime_nsec; /* creation time nanoseconds */ + int extsize; /* size of extended attribute data */ off_t size; /* size of file */ char *name; /* name of file */ } curfile; diff --git a/sbin/restore/tape.c b/sbin/restore/tape.c index 0b94e3f..d6aca48 100644 --- a/sbin/restore/tape.c +++ b/sbin/restore/tape.c @@ -48,6 +48,7 @@ static const char rcsid[] = "$OpenBSD: krw $"; #include #include #include +#include #include #include @@ -63,6 +64,7 @@ static const char rcsid[] = "$OpenBSD: krw $"; #include "restore.h" #include "extern.h" +#include "extattr.h" static long fssize = MAXBSIZE; static int mt = -1; @@ -89,6 +91,8 @@ int Bcvt; /* Swap Bytes (for CCI or sun) */ #define FLUSHTAPEBUF() blkcnt = ntrec + 1 +char *namespace_names[] = EXTATTR_NAMESPACE_NAMES; + union u_ospcl { char dummy[TP_BSIZE]; struct s_ospcl { @@ -121,12 +125,16 @@ static void accthdr(struct s_spcl *); static int checksum(int *); static void findinode(struct s_spcl *); static void findtapeblksize(void); +static char *setupextattr(int); +static void set_extattr_link(char *, void *, int); +static void set_extattr_fd(int, char *, void *, int); static int gethead(struct s_spcl *); static void readtape(char *); static void setdumpnum(void); static void swap_header(struct s_spcl *); static void swap_old_header(struct s_ospcl *); static void terminateinput(void); +static void xtrattr(char *, size_t); static void xtrfile(char *, size_t); static void xtrlnkfile(char *, size_t); static void xtrlnkskip(char *, size_t); @@ -266,7 +274,7 @@ setup(void) panic("no memory for active inode map\n"); usedinomap = map; curfile.action = USING; - getfile(xtrmap, xtrmapskip); + getfile(xtrmap, xtrmapskip, xtrmapskip); if (spcl.c_type != TS_BITS) errx(1, "Cannot find file dump list"); map = calloc((size_t)1, (size_t)howmany(maxino, NBBY)); @@ -274,7 +282,7 @@ setup(void) panic("no memory for file dump list\n"); dumpmap = map; curfile.action = USING; - getfile(xtrmap, xtrmapskip); + getfile(xtrmap, xtrmapskip, xtrmapskip); } /* @@ -516,7 +524,8 @@ extractfile(char *name) mode_t mode; struct timeval mtimep[2], ctimep[2]; struct entry *ep; - int setbirth; + char *buf; + int setbirth, extsize; curfile.name = name; curfile.action = USING; @@ -532,6 +541,8 @@ extractfile(char *name) ctimep[1].tv_sec = curfile.birthtime_sec; ctimep[1].tv_usec = curfile.birthtime_nsec / 1000; } + + extsize = curfile.extsize; uid = curfile.uid; gid = curfile.gid; mode = curfile.mode; @@ -562,7 +573,8 @@ extractfile(char *name) case IFLNK: { lnkbuf[0] = '\0'; pathlen = 0; - getfile(xtrlnkfile, xtrlnkskip); + buf = setupextattr(extsize); + getfile(xtrlnkfile, xtrattr, xtrlnkskip); if (pathlen == 0) { Vprintf(stdout, "%s: zero length symbolic link (ignored)\n", @@ -571,6 +583,8 @@ extractfile(char *name) } if (linkit(lnkbuf, name, SYMLINK) == FAIL) return (FAIL); + if (extsize > 0) + set_extattr_link(name, buf, extsize); (void)lchown(name, uid, gid); return (GOOD); } @@ -587,6 +601,13 @@ extractfile(char *name) skipfile(); return (FAIL); } + if (extsize == 0) { + skipfile(); + } else { + buf = setupextattr(extsize); + getfile(xtrnull, xtrattr, xtrnull); + set_extattr_file(name, buf, extsize); + } (void)chown(name, uid, gid); (void)chmod(name, mode); (void)chflags(name, flags); @@ -607,6 +628,13 @@ extractfile(char *name) skipfile(); return (FAIL); } + if (extsize == 0) { + skipfile(); + } else { + buf = setupextattr(extsize); + getfile(xtrnull, xtrattr, xtrnull); + set_extattr_file(name, buf, extsize); + } (void)chown(name, uid, gid); (void)chmod(name, mode); (void)chflags(name, flags); @@ -628,10 +656,13 @@ extractfile(char *name) skipfile(); return (FAIL); } + buf = setupextattr(extsize); + getfile(xtrfile, xtrattr, xtrskip); + if (extsize > 0) + set_extattr_fd(ofile, name, buf, extsize); (void)fchown(ofile, curfile.uid, curfile.gid); (void)fchmod(ofile, mode); (void)fchflags(ofile, flags); - getfile(xtrfile, xtrskip); (void)close(ofile); if (setbirth) (void)utimes(name, ctimep); @@ -642,6 +673,108 @@ extractfile(char *name) } /* + * Set attributes for a file. + */ +void +set_extattr_file(char *name, void *buf, int size) +{ + struct extattr *eap, *eaend; + + Vprintf(stdout, "Set attributes for %s:", name); + eaend = buf + size; + for (eap = buf; eap < eaend; eap = EXTATTR_NEXT(eap)) { + /* + * Make sure this entry is complete. + */ + if (EXTATTR_NEXT(eap) > eaend || eap->ea_length <= 0) { + Dprintf(stdout, "\n\t%scorrupted", + eap == buf ? "" : "remainder "); + break; + } + if (eap->ea_namespace == EXTATTR_NAMESPACE_EMPTY) + continue; + Vprintf(stdout, "\n\t%s, (%d bytes), %*s", + namespace_names[eap->ea_namespace], eap->ea_length, + eap->ea_namelength, eap->ea_name); + if (extattr_set_file(name, eap->ea_namespace, eap->ea_name, + EXTATTR_CONTENT(eap), EXTATTR_CONTENT_SIZE(eap)) != -1) { + Dprintf(stdout, " (set using extattr_set_file)"); + continue; + } + Vprintf(stdout, " (unable to set)"); + } + Vprintf(stdout, "\n"); +} + +/* + * Set attributes for a symbolic link. + */ +static void +set_extattr_link(char *name, void *buf, int size) +{ + struct extattr *eap, *eaend; + + Vprintf(stdout, "Set attributes for %s:", name); + eaend = buf + size; + for (eap = buf; eap < eaend; eap = EXTATTR_NEXT(eap)) { + /* + * Make sure this entry is complete. + */ + if (EXTATTR_NEXT(eap) > eaend || eap->ea_length <= 0) { + Dprintf(stdout, "\n\t%scorrupted", + eap == buf ? "" : "remainder "); + break; + } + if (eap->ea_namespace == EXTATTR_NAMESPACE_EMPTY) + continue; + Vprintf(stdout, "\n\t%s, (%d bytes), %*s", + namespace_names[eap->ea_namespace], eap->ea_length, + eap->ea_namelength, eap->ea_name); + if (extattr_set_link(name, eap->ea_namespace, eap->ea_name, + EXTATTR_CONTENT(eap), EXTATTR_CONTENT_SIZE(eap)) != -1) { + Dprintf(stdout, " (set using extattr_set_link)"); + continue; + } + Vprintf(stdout, " (unable to set)"); + } + Vprintf(stdout, "\n"); +} + +/* + * Set attributes on a file descriptor. + */ +static void +set_extattr_fd(int fd, char *name, void *buf, int size) +{ + struct extattr *eap, *eaend; + + Vprintf(stdout, "Set attributes for %s:", name); + eaend = buf + size; + for (eap = buf; eap < eaend; eap = EXTATTR_NEXT(eap)) { + /* + * Make sure this entry is complete. + */ + if (EXTATTR_NEXT(eap) > eaend || eap->ea_length <= 0) { + Dprintf(stdout, "\n\t%scorrupted", + eap == buf ? "" : "remainder "); + break; + } + if (eap->ea_namespace == EXTATTR_NAMESPACE_EMPTY) + continue; + Vprintf(stdout, "\n\t%s, (%d bytes), %*s", + namespace_names[eap->ea_namespace], eap->ea_length, + eap->ea_namelength, eap->ea_name); + if (extattr_set_fd(fd, eap->ea_namespace, eap->ea_name, + EXTATTR_CONTENT(eap), EXTATTR_CONTENT_SIZE(eap)) != -1) { + Dprintf(stdout, " (set using extattr_set_fd)"); + continue; + } + Vprintf(stdout, " (unable to set)"); + } + Vprintf(stdout, "\n"); +} + +/* * skip over bit maps on the tape */ void @@ -658,9 +791,8 @@ skipmaps(void) void skipfile(void) { - curfile.action = SKIP; - getfile(xtrnull, xtrnull); + getfile(xtrnull, xtrnull, xtrnull); } /* @@ -673,15 +805,18 @@ skipfile(void) * and no blocks should be skipped. */ void -getfile(void (*fill)(char *, size_t), void (*skip)(char *, size_t)) +getfile(void (*datafill)(char *, size_t), void (*attrfill)(char *, size_t), + void (*skip)(char *, size_t)) { int i; volatile int curblk = 0; volatile off_t size = spcl.c_size; + volatile off_t attrsize = spcl.c_extsize; static char clearedbuf[MAXBSIZE]; char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE]; char junk[TP_BSIZE]; volatile int noskip = (spcl.c_type == TS_BITS || spcl.c_type == TS_CLRI); + void (*fillit)(char *, size_t); if (spcl.c_type == TS_END) panic("ran off end of tape\n"); @@ -690,19 +825,25 @@ getfile(void (*fill)(char *, size_t), void (*skip)(char *, size_t)) if (!gettingfile && setjmp(restart) != 0) return; gettingfile++; + fillit = datafill; + if (size == 0 && attrsize > 0) { + fillit = attrfill; + size = attrsize; + attrsize = 0; + } loop: for (i = 0; i < spcl.c_count; i++) { if (noskip || spcl.c_addr[i]) { readtape(&buf[curblk++][0]); if (curblk == fssize / TP_BSIZE) { - (*fill)((char *)buf, size > TP_BSIZE ? + (*fillit)((char *)buf, size > TP_BSIZE ? fssize : ((off_t)curblk - 1) * TP_BSIZE + size); curblk = 0; } } else { if (curblk > 0) { - (*fill)((char *)buf, size > TP_BSIZE ? + (*fillit)((char *)buf, size > TP_BSIZE ? (curblk * TP_BSIZE) : ((off_t)curblk - 1) * TP_BSIZE + size); curblk = 0; @@ -711,6 +852,17 @@ loop: TP_BSIZE : size); } if ((size -= TP_BSIZE) <= 0) { + if (size > -TP_BSIZE && curblk > 0) { + (*fillit)((char *)buf, + (size_t)((curblk * TP_BSIZE) + size)); + curblk = 0; + } + if (attrsize > 0) { + fillit = attrfill; + size = attrsize; + attrsize = 0; + continue; + } for (i++; i < spcl.c_count; i++) if (noskip || spcl.c_addr[i]) readtape(junk); @@ -725,12 +877,53 @@ loop: curfile.name, blksread); } if (curblk > 0) - (*fill)((char *)buf, ((off_t)curblk * TP_BSIZE) + size); + panic("getfile: lost data\n"); findinode(&spcl); gettingfile = 0; } /* + * These variables are shared between the next two functions. + */ +static int extbufsize = 0; +static char *extbuf; +static size_t extloc; + +/* + * Allocate a buffer into which to extract extended attributes. + */ +static char * +setupextattr(int extsize) +{ + extloc = 0; + if (extsize <= extbufsize) + return (extbuf); + if (extbufsize > 0) + free(extbuf); + if ((extbuf = malloc(extsize)) != NULL) { + extbufsize = extsize; + return (extbuf); + } + extbufsize = 0; + extbuf = NULL; + fprintf(stderr, "Cannot extract %d bytes %s for inode %d, name %s\n", + extsize, "of extended attributes", curfile.ino, curfile.name); + return (NULL); +} + +/* + * Extract the next block of extended attributes. + */ +static void +xtrattr(char *buf, size_t size) +{ + if (extloc + size > extbufsize) + panic("overrun attribute buffer\n"); + memmove(&extbuf[extloc], buf, size); + extloc += size; +} + +/* * Write out the next block of a file. */ static void @@ -1209,7 +1402,9 @@ findinode(struct s_spcl *header) curfile.birthtime_sec = header->c_birthtime; curfile.birthtime_nsec = header->c_birthtimensec; curfile.size = header->c_size; + curfile.extsize = header->c_extsize; curfile.ino = header->c_inumber; + Dprintf(stdout, "inode %lld has %d bytes long extattr area\n", (int64_t)curfile.ino, curfile.extsize); break; case TS_END: diff --git a/sbin/sysctl/sysctl.c b/sbin/sysctl/sysctl.c index a82652c..b3e5af4 100644 --- a/sbin/sysctl/sysctl.c +++ b/sbin/sysctl/sysctl.c @@ -141,6 +141,15 @@ struct ctlname *vfsname; struct ctlname machdepname[] = CTL_MACHDEP_NAMES; #endif struct ctlname ddbname[] = CTL_DDB_NAMES; +#ifdef CTL_SECURITY_NAMES +struct ctlname securityname[] = CTL_SECURITY_NAMES; +#endif +#ifdef SECURITY_MAC_TEST +struct ctlname mactestname[] = MAC_TEST_NAMES; +#endif +#ifdef SECURITY_ANOUBIS +struct ctlname anoubisname[] = ANOUBIS_NAMES; +#endif char names[BUFSIZ]; int lastused; @@ -168,6 +177,11 @@ struct list secondlevel[] = { { username, USER_MAXID }, /* CTL_USER_NAMES */ { ddbname, DBCTL_MAXID }, /* CTL_DDB_NAMES */ { 0, 0 }, /* CTL_VFS */ +#ifdef CTL_SECURITY_NAMES + { securityname, SECURITY_MAXID }, /* CTL_SECURITY */ +#else + { 0, 0 }, +#endif }; int Aflag, aflag, nflag, qflag; @@ -223,6 +237,9 @@ int sysctl_emul(char *, char *, int); #ifdef CPU_CHIPSET int sysctl_chipset(char *, char **, int *, int, int *); #endif +#if defined(SECURITY_MAC_TEST) || defined (SECURITY_ANOUBIS) +void sysctl_security(char *, char *, int, int, char *, struct ctlname *); +#endif void vfsinit(void); char *equ = "="; @@ -677,6 +694,23 @@ parse(char *string, int flags) } return; + case CTL_SECURITY: +#ifdef SECURITY_MAC_TEST + if (mib[1] == SECURITY_MAC_TEST) { + sysctl_security(string, newval, SECURITY_MAC_TEST, + MAC_TEST_MAXID, "security.mac_test", mactestname); + return; + } +#endif +#ifdef SECURITY_ANOUBIS + if (mib[1] == SECURITY_ANOUBIS) { + sysctl_security(string, newval, SECURITY_ANOUBIS, + ANOUBIS_MAXID, "security.mac_anoubis", anoubisname); + return; + } +#endif + break; + case CTL_USER: case CTL_DDB: break; @@ -2623,6 +2657,90 @@ emul_init(void) return (0); } +#if defined(SECURITY_MAC_TEST) || defined(SECURITY_ANOUBIS) +void +sysctl_security(char *string, char *newval, int ctl, int maxid, char *head, + struct ctlname *name) +{ + int mib[3], i, found, old, value; + char *target; + const char *errstr; + size_t len; + + mib[0] = CTL_SECURITY; + mib[1] = ctl; + + if (aflag || strcmp(string, head) == 0) { + if (newval) { + warnx("%s: specification is incomplete", string); + return; + } + for (i = 1; i < maxid; i++) { + mib[2] = i; + len = sizeof(int); + if (sysctl(mib, 3, &value, &len, NULL, 0) == -1) { + warn("%s", string); + continue; + } + if (nflag) + printf("%d\n", value); + else + printf("%s.%s%s%d\n", head, + name[i].ctl_name, equ, value); + } + return; + } + + target = string + strlen(head); + if (*target++ && *target == '\0') { + warnx("no third level name specified"); + return; + } + + found = 0; + for (i = 1; i < maxid; i++) { + if (strcmp(target, name[i].ctl_name)) + continue; + found = 1; + + mib[2] = i; + len = sizeof(int); + + if (newval) { + value = strtonum(newval, INT_MIN, INT_MAX, &errstr); + if (errstr) { + warnx("value %s is %s", newval, errstr); + return; + } + if (sysctl(mib, 3, &old, &len, &value, len) == -1) { + warn("%s", string); + return; + } + if (nflag) + printf("%d\n", value); + else + printf("%s.%s: %d -> %d\n", head, target, + old, value); + } else { + if (sysctl(mib, 3, &value, &len, NULL, 0) == -1) { + warn("%s", string); + return; + } + if (nflag) + printf("%d\n", value); + else + printf("%s.%s = %d\n", head, target, value); + } + break; + } + if (!found) + warnx("third level name \"%s\" in %s is invalid", + target, head); + + return; +} +#endif /* SECURITY_MAC_TEST || SECURITY_ANOUBIS */ + /* * Scan a list of names searching for a particular name. */ diff --git a/sbin/tunefs/tunefs.8 b/sbin/tunefs/tunefs.8 index 14aec97..1042e65 100644 --- a/sbin/tunefs/tunefs.8 +++ b/sbin/tunefs/tunefs.8 @@ -40,9 +40,11 @@ .Nm .Bk -words .Op Fl AFN +.Op Fl a Cm set | unset .Op Fl e Ar maxbpg .Op Fl g Ar avgfilesize .Op Fl h Ar avgfpdir +.Op Fl l Cm set | unset .Op Fl m Ar minfree .\" .Op Fl n Ar soft_dependency_enabling .Op Fl o Ar optimize_preference @@ -67,6 +69,8 @@ will lose anything changed by is ignored when .Fl N is specified. +.It Fl a Cm set | unset +Set or unset the administrative ACL flag in the superblock. .It Fl e Ar maxbpg This indicates the maximum number of blocks any single file can allocate out of a cylinder group before it is forced to begin @@ -93,6 +97,8 @@ will be accessed This specifies the expected average file size. .It Fl h Ar avgfpdir This specifies the expected number of files per directory. +.It Fl l Cm set | unset +Set or unset the multilabel MAC flag in the superblock. .It Fl m Ar minfree This value specifies the percentage of space held back from normal users; the minimum free space threshold. diff --git a/sbin/tunefs/tunefs.c b/sbin/tunefs/tunefs.c index 23c58e8..9dbe21a 100644 --- a/sbin/tunefs/tunefs.c +++ b/sbin/tunefs/tunefs.c @@ -91,14 +91,14 @@ static void usage(void); int main(int argc, char *argv[]) { -#define OPTSTRING "AFNe:g:h:m:o:" - int i, ch, Aflag, Fflag, Nflag, openflags; +#define OPTSTRING "AFNa:e:g:h:l:m:o:" + int i, ch, Aflag, Fflag, Nflag, aflag, lflag, openflags; const char *special, *chg[2]; char device[MAXPATHLEN]; - int maxbpg, minfree, optim; + int maxbpg, minfree, optim, aclset, macset; int avgfilesize, avgfpdir; - Aflag = Fflag = Nflag = 0; + Aflag = Fflag = Nflag = aflag = lflag = 0; maxbpg = minfree = optim = -1; avgfilesize = avgfpdir = -1; chg[FS_OPTSPACE] = "space"; @@ -119,6 +119,16 @@ main(int argc, char *argv[]) Nflag++; break; + case 'a': + aflag++;; + if (!strcmp(optarg, "set")) + aclset = 1; + else if (!strcmp(optarg, "unset")) + aclset = 0; + else + errx(10, "invalid argument for option -a"); + break; + case 'e': maxbpg = getnum(optarg, "maximum blocks per file in a cylinder group", @@ -136,6 +146,16 @@ main(int argc, char *argv[]) 1, INT_MAX); break; + case 'l': + lflag++;; + if (!strcmp(optarg, "set")) + macset = 1; + else if (!strcmp(optarg, "unset")) + macset = 0; + else + errx(10, "invalid argument for option -l"); + break; + case 'm': minfree = getnum(optarg, "minimum percentage of free space", 0, 99); @@ -186,6 +206,51 @@ main(int argc, char *argv[]) } while (/* CONSTCOND */0) warnx("tuning %s", special); + + if (aflag) { + if (aclset) { + if (sblock.fs_flags & FS_ACLS) + warnx("administrative ACL flag remains " + "unchanged and set"); + else { + sblock.fs_flags |= FS_ACLS; + warnx("administrative ACL flag changes from " + "unset to set"); + } + } else { + if (!(sblock.fs_flags & FS_ACLS)) + warnx("administrative ACL flag remains " + "unchanged and unset"); + else { + sblock.fs_flags &= ~FS_ACLS; + warnx("administrative ACL flag changes from " + "set to unset"); + } + } + } + + if (lflag) { + if (macset) { + if (sblock.fs_flags & FS_MULTILABEL) + warnx("multilabel MAC flag remains " + "unchanged and set"); + else { + sblock.fs_flags |= FS_MULTILABEL; + warnx("multilabel MAC flag changes from " + "unset to set"); + } + } else { + if (!(sblock.fs_flags & FS_MULTILABEL)) + warnx("multilabel MAC flag remains " + "unchanged and unset"); + else { + sblock.fs_flags &= ~FS_MULTILABEL; + warnx("multilabel MAC flag changes from " + "set to unset"); + } + } + } + CHANGEVAL(sblock.fs_maxbpg, maxbpg, "maximum blocks per file in a cylinder group", ""); CHANGEVAL(sblock.fs_minfree, minfree, @@ -223,6 +288,8 @@ main(int argc, char *argv[]) if (Nflag) { fprintf(stdout, "tunefs: current settings of %s\n", special); + fprintf(stdout, "\tadministrative ACL flag %s\n", + (sblock.fs_flags & FS_ACLS) ? "set" : "unset"); fprintf(stdout, "\tmaximum contiguous block count %d\n", sblock.fs_maxcontig); fprintf(stdout, @@ -269,8 +336,8 @@ usage(void) extern char *__progname; fprintf(stderr, - "usage: %s [-AFN] [-e maxbpg] [-g avgfilesize] " - "[-h avgfpdir] [-m minfree]\n" + "usage: %s [-AFN] [-a set | unset] [-e maxbpg] [-g avgfilesize] " + "[-h avgfpdir] [-l set | unset] [-m minfree]\n" "\t[-o optimize_preference] special | filesys\n", __progname); diff --git a/share/man/man7/Makefile b/share/man/man7/Makefile index 0a86e63..0da0646 100644 --- a/share/man/man7/Makefile +++ b/share/man/man7/Makefile @@ -4,8 +4,9 @@ # missing: eqnchar.7 man.7 ms.7 term.7 MAN= ascii.7 environ.7 glob.7 hier.7 hostname.7 intro.7 kgdb.7 \ - library-specs.7 mailaddr.7 mdoc.7 mdoc.samples.7 mirroring-ports.7 \ - operator.7 packages.7 packages-specs.7 ports.7 script.7 securelevel.7 + library-specs.7 maclabel.7 mailaddr.7 mdoc.7 mdoc.samples.7 \ + mirroring-ports.7 operator.7 packages.7 packages-specs.7 ports.7 \ + script.7 securelevel.7 MLINKS= mdoc.7 mandoc.7 mdoc.samples.7 mandoc.samples.7 \ mirroring-ports.7 mirror-maker.7 diff --git a/share/man/man7/maclabel.7 b/share/man/man7/maclabel.7 new file mode 100644 index 0000000..f217e8b --- /dev/null +++ b/share/man/man7/maclabel.7 @@ -0,0 +1,102 @@ +.\" Copyright (c) 2002 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project by Chris Costello +.\" at Safeport Network Services and Network Associates Labs, the Security +.\" Research Division of Network Associates, Inc. under DARPA/SPAWAR +.\" contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS research +.\" program. +.\" +.\" 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. +.\" 3. The names of the authors may not be used to endorse or promote +.\" products derived from this software without specific prior written +.\" permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``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 AUTHORS OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: maclabel.7,v 1.6 2004/07/03 18:29:23 ru Exp $ +.\" +.Dd October 25, 2002 +.Os +.Dt MACLABEL 7 +.Sh NAME +.Nm maclabel +.Nd Mandatory Access Control label format +.Sh DESCRIPTION +If Mandatory Access Control, or MAC, is enabled in the kernel, +then in addition to the traditional credentials, +each subject +(typically a user or a socket) +and object +(file system object, socket, etc.\&) +is given a +.Em "MAC label" . +The MAC label specifies the necessary subject-specific or +object-specific information necessary for a MAC security policy +.\" .Pq Xr mac 9 +to enforce access control on the subject/object. +.Pp +The format for a MAC label is defined as follows: +.Pp +.Sm off +.D1 Ar policy1 No / Ar qualifier1 , +.D1 Ar policy2 No / Ar qualifier2 , +.D1 ... +.Sm on +.Pp +A MAC label consists of a policy name, +followed by a forward slash, +followed by the subject or object's qualifier, +optionally followed by a comma and one or more additional policy labels. +For example: +.Bd -literal -offset indent +biba/low(low-low) +biba/high(low-high), +mls/equal(equal-equal), +partition/0 +.Ed +.Sh SEE ALSO +.Xr mac 3 , +.Xr posix1e 3 , +.Xr mac_biba 4 , +.Xr mac_bsdextended 4 , +.Xr mac_ifoff 4 , +.Xr mac_mls 4 , +.Xr mac_none 4 , +.Xr mac_partition 4 , +.Xr mac_seeotheruids 4 , +.Xr mac_test 4 , +.Xr login.conf 5 , +.Xr getfmac 8 , +.Xr getpmac 8 , +.Xr ifconfig 8 , +.Xr setfmac 8 , +.Xr setpmac 8 , +.Xr mac 9 +.Sh HISTORY +MAC first appeared in +.Fx 5.0 . +.Sh AUTHORS +This software was contributed to the +.Fx +Project by NAI Labs, the Security Research Division of Network Associates +Inc.\& under DARPA/SPAWAR contract N66001-01-C-8035 +.Pq Dq CBOSS , +as part of the DARPA CHATS research program. diff --git a/share/man/man9/Makefile b/share/man/man9/Makefile index 15a3538..474494f 100644 --- a/share/man/man9/Makefile +++ b/share/man/man9/Makefile @@ -21,14 +21,16 @@ MAN= altq.9 aml_evalnode.9 atomic.9 audio.9 autoconf.9 bio_register.9 \ panic.9 pci_conf_read.9 pci_intr_map.9 pfind.9 physio.9 pmap.9 \ pool.9 powerhook_establish.9 ppsratecheck.9 printf.9 psignal.9 \ radio.9 random.9 rasops.9 ratecheck.9 resettodr.9 rssadapt.9 rwlock.9 \ - sensor_attach.9 \ + sbuf.9 sensor_attach.9 \ shutdownhook_establish.9 tsleep.9 spl.9 startuphook_establish.9 \ socreate.9 style.9 syscall.9 systrace.9 sysctl_int.9 \ tc_init.9 time.9 timeout.9 tvtohz.9 uiomove.9 uvm.9 vfs.9 vfs_busy.9 \ - vfs_cache.9 vaccess.9 vclean.9 vcount.9 vdevgone.9 vfinddev.9 vflush.9 \ + vfs_cache.9 vfs_extattr.9 vaccess.9 vclean.9 vcount.9 vdevgone.9 \ + vfinddev.9 vflush.9 \ vflushbuf.9 vget.9 vgone.9 vhold.9 vinvalbuf.9 vnode.9 vnsubr.9 \ - VOP_GETATTR.9 VOP_LOOKUP.9 vput.9 vrecycle.9 vref.9 vrele.9 \ - vwaitforio.9 vwakeup.9 wdog_register.9 workq_add_task.9 + VOP_GETATTR.9 VOP_GETEXTATTR.9 VOP_LISTEXTATTR.9 VOP_LOOKUP.9 \ + VOP_SETEXTATTR.9 vput.9 vrecycle.9 vref.9 vrele.9 vwaitforio.9 \ + vwakeup.9 wdog_register.9 workq_add_task.9 MLINKS+=aml_evalnode.9 aml_evalname.9 aml_evalnode.9 aml_find_node.9 \ aml_evalnode.9 aml_freevalue.9 aml_evalnode.9 aml_val2int.9 @@ -264,7 +266,25 @@ MLINKS+=rssadapt.9 ieee80211_rssadapt_choose.9 \ MLINKS+=rwlock.9 rw_init.9 rwlock.9 rw_enter.9 rwlock.9 rw_exit.9 \ rwlock.9 rw_enter_read.9 rwlock.9 rw_enter_write.9 \ rwlock.9 rw_exit_read.9 rwlock.9 rw_exit_write.9 - +MLINKS+=sbuf.9 sbuf_bcat.9 \ + sbuf.9 sbuf_bcopyin.9 \ + sbuf.9 sbuf_bcpy.9 \ + sbuf.9 sbuf_cat.9 \ + sbuf.9 sbuf_clear.9 \ + sbuf.9 sbuf_copyin.9 \ + sbuf.9 sbuf_cpy.9 \ + sbuf.9 sbuf_data.9 \ + sbuf.9 sbuf_delete.9 \ + sbuf.9 sbuf_done.9 \ + sbuf.9 sbuf_finish.9 \ + sbuf.9 sbuf_len.9 \ + sbuf.9 sbuf_new.9 \ + sbuf.9 sbuf_overflowed.9 \ + sbuf.9 sbuf_printf.9 \ + sbuf.9 sbuf_putc.9 \ + sbuf.9 sbuf_setpos.9 \ + sbuf.9 sbuf_trim.9 \ + sbuf.9 sbuf_vprintf.9 MLINKS+=sensor_attach.9 sensordev_install.9 \ sensor_attach.9 sensordev_deinstall.9 \ sensor_attach.9 sensordev_get.9 \ diff --git a/share/man/man9/VOP_GETEXTATTR.9 b/share/man/man9/VOP_GETEXTATTR.9 new file mode 100644 index 0000000..cf452b8 --- /dev/null +++ b/share/man/man9/VOP_GETEXTATTR.9 @@ -0,0 +1,128 @@ +.\" +.\" Copyright (c) 1999, 2000, 2001, 2003 Robert N. M. Watson +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: VOP_GETEXTATTR.9,v 1.22 2005/01/28 10:43:05 ru Exp $ +.\" +.Dd December 23, 1999 +.Os +.Dt VOP_GETEXTATTR 9 +.Sh NAME +.Nm VOP_GETEXTATTR +.Nd retrieve extended attribute from a vnode +.Sh SYNOPSIS +.In sys/param.h +.In sys/vnode.h +.In sys/extattr.h +.Ft int +.Fo VOP_GETEXTATTR +.Fa "struct vnode *vp" +.Fa "int attrnamespace" +.Fa "const char *name" +.Fa "struct uio *uio" +.Fa "size_t *size" +.Fa "struct ucred *cred" +.Fa "struct proc *p" +.Fc +.Sh DESCRIPTION +This vnode call may be used to retrieve a specific extended attribute from a +file, directory or symbolic link. +.Pp +Arguments are: +.Bl -tag -width ".Fa attrnamespace" +.It Fa vp +The vnode of the file, directory or symbolic link. +.It Fa attrnamespace +Integer constant indicating which extended attribute namespace the attribute +name is present in. +.It Fa name +Pointer to a null-terminated character string containing the attribute name. +.It Fa uio +The location of the data to be read. +.It Fa size +If not +.Dv NULL , +on return it will contain the number of bytes required to read all of the +attribute data. +In most cases +.Fa uio +will be +.Dv NULL +when +.Fa size +is not, and vice versa. +.It Fa cred +The credentials to use in authorizing the request. +.It Fa p +The process requesting the extended attribute. +.El +.Pp +The +.Fa cred +pointer may be +.Dv NULL +to indicate that access control checks are not to be performed, if possible. +This +.Fa cred +setting might be used to allow the kernel to authorize extended attribute +retrieval that the active process might not be permitted to do. +.Pp +Extended attribute semantics may vary by file system implementing the call. +More information on extended attributes may be found in +.Xr vfs_extattr 9 . +.Sh LOCKS +The vnode should be locked on entry and remains locked on return. +.Sh RETURN VALUES +On success, zero will be returned, and the uio structure will be updated to +reflect the data read. +Otherwise, an appropriate error code is returned. +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EACCES +The the caller does not have the appropriate privilege. +.It Bq Er EFAULT +The uio structure refers to an invalid userspace address. +.It Bq Er EINVAL +The +.Fa name , +.Fa namespace, +or +.Fa uio +argument is invalid. +.It Bq Er ENOATTR +The requested attribute was not defined for this vnode. +.It Bq Er ENOMEM +Sufficient memory is not available to fulfill the request. +.It Bq Er ENXIO +The request was not valid in this file system for the specified vnode and +attribute name. +.It Bq Er EOPNOTSUPP +The file system does not support +.Fn VOP_GETEXTATTR . +.El +.Sh SEE ALSO +.Xr vfs_extattr 9 , +.Xr vnode 9 , +.Xr VOP_SETEXTATTR 9 , +.Xr VOP_LISTEXTATTR 9 diff --git a/share/man/man9/VOP_LISTEXTATTR.9 b/share/man/man9/VOP_LISTEXTATTR.9 new file mode 100644 index 0000000..227c188 --- /dev/null +++ b/share/man/man9/VOP_LISTEXTATTR.9 @@ -0,0 +1,136 @@ +.\" +.\" Copyright (c) 2003 Network Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed for the FreeBSD Project in part by Network +.\" Associates Laboratories, the Security Research Division of Network +.\" Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), +.\" as part of the DARPA CHATS research program. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: VOP_LISTEXTATTR.9,v 1.7 2005/08/19 12:17:47 rodrigc Exp $ +.\" +.Dd August 19, 2005 +.Os +.Dt VOP_LISTEXTATTR 9 +.Sh NAME +.Nm VOP_LISTEXTATTR +.Nd retrieve a list of extended attributes from a vnode +.Sh SYNOPSIS +.In sys/param.h +.In sys/vnode.h +.In sys/extattr.h +.Ft int +.Fo VOP_LISTEXTATTR +.Fa "struct vnode *vp" +.Fa "int attrnamespace" +.Fa "struct uio *uio" +.Fa "size_t *size" +.Fa "struct ucred *cred" +.Fa "struct proc *p" +.Fc +.Sh DESCRIPTION +This vnode call may be used to retrieve a list of named extended attributes +from a specified namespace on a file, directory or symbolic link. +.Pp +Arguments are: +.Bl -tag -width ".Fa attrnamespace" +.It Fa vp +The vnode of the file, directory or symbolic link. +.It Fa attrnamespace +Integer constant indicating which extended attribute namespace the attribute +name is present in. +.It Fa uio +The location of the data to be read. +The resulting data will be a list of attribute names. +Each list entry consists of a single byte containing the length of +the attribute name, followed by the attribute name. +The attribute name is not terminated by +.Tn ASCII +.Dv NUL . +.It Fa size +If not +.Dv NULL , +on return it will contain the number of bytes required to read the list. +In most cases +.Fa uio +will be +.Dv NULL +when +.Fa size +is not, and vise versa. +.It Fa cred +The credentials to use in authorizing the request. +.It Fa p +The process requesting the list of extended attributes. +.El +.Pp +The +.Fa cred +pointer may be +.Dv NULL +to indicate that access control checks are not to be performed, if possible. +This +.Fa cred +setting might be used to allow the kernel to authorize extended attribute +retrieval that the active process might not be permitted to do. +.Pp +Extended attribute semantics may vary by file system implementing the call. +More information on extended attributes may be found in +.Xr vfs_extattr 9 . +.Sh LOCKS +The vnode should be locked on entry and remains locked on return. +.Sh RETURN VALUES +On success, zero will be returned, and the +.Fa uio +structure will be updated to +reflect the list read. +Otherwise, an appropriate error code is returned. +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EACCES +The caller does not have the appropriate privilege. +.It Bq Er EFAULT +The +.Fa uio +structure refers to an invalid userspace address. +.It Bq Er EINVAL +The +.Fa namespace +or +.Fa uio +argument is invalid. +.It Bq Er ENOMEM +Sufficient memory is not available to fulfill the request. +.It Bq Er ENXIO +The request was not valid in this file system for the specified vnode and +attribute name. +.It Bq Er EOPNOTSUPP +The file system does not support +.Fn VOP_LISTEXTATTR . +.El +.Sh SEE ALSO +.Xr vfs_extattr 9 , +.Xr vnode 9 , +.Xr VOP_GETEXTATTR 9 , +.Xr VOP_SETEXTATTR 9 diff --git a/share/man/man9/VOP_SETEXTATTR.9 b/share/man/man9/VOP_SETEXTATTR.9 new file mode 100644 index 0000000..02f7665 --- /dev/null +++ b/share/man/man9/VOP_SETEXTATTR.9 @@ -0,0 +1,116 @@ +.\" +.\" Copyright (c) 1999, 2000, 2001 Robert N. M. Watson +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: VOP_SETEXTATTR.9,v 1.20 2005/06/28 20:15:18 hmp Exp $ +.\" +.Dd December 23, 1999 +.Os +.Dt VOP_SETEXTATTR 9 +.Sh NAME +.Nm VOP_SETEXTATTR +.Nd set extended attribute on a vnode +.Sh SYNOPSIS +.In sys/param.h +.In sys/vnode.h +.In sys/extattr.h +.Ft int +.Fn VOP_SETEXTATTR "struct vnode *vp" "int attrnamespace" "const char *name" "struct uio *uio" "struct ucred *cred" "struct proc *p" +.Sh DESCRIPTION +This vnode call may be used to set specific extended attribute on a +file, directory or symbolic link. +.Pp +Arguments are: +.Bl -tag -width ".Fa attrnamespace" +.It Fa vp +The vnode of the file, directory or symbolic link. +.It Fa attrnamespace +Integer constant indicating which extended attribute namespace the attribute +name is present in. +.It Fa name +Pointer to a null-terminated character string containing the attribute name. +.It Fa uio +The location of the data to be written. +.It Fa cred +The credentials to use in authorizing the request. +.It Fa p +The process setting the extended attribute. +.El +.Pp +The uio structure is used in a manner similar to the argument of the same +name in +.Xr VOP_WRITE 9 . +However, as extended attributes provide a strict "name, value" semantic, +non-zero offsets will be rejected. +.Pp +The +.Fa uio +pointer may be +.Dv NULL +to indicate that the specified extended attribute should be deleted. +.Pp +The +.Fa cred +pointer may be +.Dv NULL +to indicate that access control checks are not to be performed, if possible. +This +.Fa cred +setting might be used to allow the kernel to authorize extended attribute +changes that the active process might not be permitted to make. +.Pp +Extended attribute semantics may vary by file system implementing the call. +More information on extended attributes may be found in +.Xr vfs_extattr 9 . +.Sh LOCKS +The vnode should be locked on entry and remains locked on return. +.Sh RETURN VALUES +If the extended attribute is successfully set, then zero is returned. +Otherwise, an appropriate error code is returned. +.Sh ERRORS +.Bl -tag -width Er +.It Bq Er EACCES +The the caller does not have the appropriate privilege. +.It Bq Er EFAULT +The uio structure refers to an invalid userspace address. +.It Bq Er EINVAL +The name, namespace, or uio argument is invalid. +.It Bq Er ENOMEM +Insufficient memory available to fulfill request +.It Bq Er ENOSPC +The file system is out of space. +.It Bq Er ENXIO +The request was not valid in this file system for the specified vnode and +attribute name. +.It Bq Er EOPNOTSUPP +The file system does not support +.Fn VOP_SETEXTATTR . +.It Bq Er EROFS +The file system is read-only. +.El +.Sh SEE ALSO +.Xr vfs_extattr 9 , +.Xr vnode 9 , +.Xr VOP_GETEXTATTR 9 , +.Xr VOP_LISTEXTATTR 9 diff --git a/share/man/man9/mac.9 b/share/man/man9/mac.9 new file mode 100644 index 0000000..c529fb4 --- /dev/null +++ b/share/man/man9/mac.9 @@ -0,0 +1,246 @@ +.\"- +.\" Copyright (c) 1999-2002 Robert N. M. Watson +.\" Copyright (c) 2002-2004 Networks Associates Technology, Inc. +.\" All rights reserved. +.\" +.\" This software was developed by Robert Watson for the TrustedBSD Project. +.\" +.\" This software was developed for the FreeBSD Project in part by Network +.\" Associates Laboratories, the Security Research Division of Network +.\" Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 +.\" ("CBOSS"), as part of the DARPA CHATS research program. +.\" +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: src/share/man/man9/mac.9,v 1.17 2006/07/11 16:26:40 joel Exp $ +.\" +.Dd July 10, 2006 +.Dt MAC 9 +.Os +.Sh NAME +.Nm mac +.Nd TrustedBSD Mandatory Access Control framework +.Sh SYNOPSIS +.In sys/types.h +.In sys/mac.h +.Pp +In the kernel configuration file: +.Cd "options MAC" +.Cd "options MAC_DEBUG" +.Sh DESCRIPTION +.Ss Introduction +The +.Tn TrustedBSD +mandatory access control framework permits dynamically +introduced system security modules to modify system security functionality. +This can be used to support a variety of new security services, including +traditional labeled mandatory access control models. +The framework provides a series of entry points which must be called by +code supporting various kernel services, especially with respects to access +control points and object creation. +The framework then calls out to security modules to offer them the +opportunity to modify security behavior at those MAC API entry points. +Both consumers of the API (normal kernel services) and security modules +must be aware of the semantics of the API calls, particularly with respect +to synchronization primitives (such as locking). +.Ss Note on Appropriateness for Production Use +The +.Tn TrustedBSD +MAC Framework included in +.Fx 5.0 +is considered experimental, and should not be deployed in production +environments without careful consideration of the risks associated with +the use of experimental operating system features. +.Ss Kernel Objects Supported by the Framework +The MAC framework manages labels on a variety of types of in-kernel +objects, including process credentials, vnodes, devfs_dirents, mount +points, sockets, mbufs, bpf descriptors, network interfaces, IP fragment +queues, and pipes. +Label data on kernel objects, represented by +.Vt "struct label" , +is policy-unaware, and may be used in the manner seen fit by policy modules. +.Ss API for Consumers +The MAC API provides a large set of entry points, too broad to specifically +document here. +In general, these entry points represent an access control check or other +MAC-relevant operations, accept one or more subjects (credentials) +authorizing the activity, a set of objects on which the operation +is to be performed, and a set of operation arguments providing information +about the type of operation being requested. +.Ss Locking for Consumers +Consumers of the MAC API must be aware of the locking requirements for +each API entry point: generally, appropriate locks must be held over each +subject or object being passed into the call, so that MAC modules may +make use of various aspects of the object for access control purposes. +For example, vnode locks are frequently required in order that the MAC +framework and modules may retrieve security labels and attributes from the +vnodes for the purposes of access control. +Similarly, the caller must be aware of the reference counting semantics +of any subject or object passed into the MAC API: all calls require that +a valid reference to the object be held for the duration of the +(potentially lengthy) MAC API call. +Under some circumstances, objects must be held in either a shared or +exclusive manner. +.Ss API for Module Writers +Each module exports a structure describing the MAC API operations that +the module chooses to implement, including initialization and destruction +API entry points, a variety of object creation and destruction calls, +and a large set of access control check points. +In the future, additional audit entry points will also be present. +Module authors may choose to only implement a subset of the entry points, +setting API function pointers in the description structure to +.Dv NULL , +permitting the framework to avoid calling into the module. +.Ss Locking for Module Writers +Module writers must be aware of the locking semantics of entry points +that they implement: MAC API entry points will have specific locking +or reference counting semantics for each argument, and modules must follow +the locking and reference counting protocol or risk a variety of failure +modes (including race conditions, inappropriate pointer dereferences, +etc). +.Pp +MAC module writers must also be aware that MAC API entry points will +frequently be invoked from deep in a kernel stack, and as such must be +careful to avoid violating more global locking requirements, such as +global lock order requirements. +For example, it may be inappropriate to lock additional objects not +specifically maintained and ordered by the policy module, or the +policy module might violate a global ordering requirement relating +to those additional objects. +.Pp +Finally, MAC API module implementors must be careful to avoid +inappropriately calling back into the MAC framework: the framework +makes use of locking to prevent inconsistencies during policy module +attachment and detachment. +MAC API modules should avoid producing scenarios in which deadlocks +or inconsistencies might occur. +.Ss Adding New MAC Entry Points +The MAC API is intended to be easily expandable as new services are +added to the kernel. +In order that policies may be guaranteed the opportunity to ubiquitously +protect system subjects and objects, it is important that kernel +developers maintain awareness of when security checks or relevant +subject or object operations occur in newly written or modified kernel +code. +New entry points must be carefully documented so as to prevent any +confusion regarding lock orders and semantics. +Introducing new entry points requires four distinct pieces of work: +introducing new MAC API entries reflecting the operation arguments, +scattering these MAC API entry points throughout the new or modified +kernel service, extending the front-end implementation of the MAC API +framework, and modifying appropriate modules to take advantage of +the new entry points so that they may consistently enforce their +policies. +.Sh ENTRY POINTS +System service and module authors should reference the +.%T "FreeBSD Architecture Handbook" +for information on the MAC Framework APIs. +.Sh SEE ALSO +.\".Xr acl 3 , +.\".Xr mac 3 , +.\".Xr posix1e 3 , +.\".Xr mac_biba 4 , +.\".Xr mac_bsdextended 4 , +.\".Xr mac_ifoff 4 , +.\".Xr mac_lomac 4 , +.\".Xr mac_mls 4 , +.\".Xr mac_none 4 , +.\".Xr mac_partition 4 , +.\".Xr mac_seeotheruids 4 , +.\".Xr mac_test 4 , +.\".Xr ucred 9 , +.Xr vaccess 9 +.\".Xr vaccess_acl_posix1e 9 , +.\".Xr VFS 9 +.Rs +.%T "The FreeBSD Architecture Handbook" +.%O "http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/arch-handbook/" +.Re +.Sh HISTORY +The +.Tn TrustedBSD +MAC Framework first appeared in +.Fx 5.0 . +.Sh AUTHORS +This manual page was written by +.An Robert Watson . +This software was contributed to the +.Fx +Project by Network Associates Laboratories, the Security Research +Division of Network Associates Inc.\& under DARPA/SPAWAR contract +N66001-01-C-8035 +.Pq Dq CBOSS , +as part of the DARPA CHATS research program. +.Pp +.An -nosplit +The +.Tn TrustedBSD +MAC Framework was designed by +.An Robert Watson , +and implemented by the Network Associates Laboratories Network Security +(NETSEC), Secure Execution Environment (SEE), and Adaptive +Network Defense research groups. +Network Associates Laboratory staff contributing to the CBOSS Project +include (in alphabetical order): +.An Lee Badger , +.An Brian Feldman , +.An Hrishikesh Dandekar , +.An Tim Fraser , +.An Doug Kilpatrick , +.An Suresh Krishnaswamy , +.An Adam Migus , +.An Wayne Morrison , +.An Andrew Reisse , +.An Chris Vance , +and +.An Robert Watson . +.Pp +Sub-contracted staff include: +.An Chris Costello , +.An Poul-Henning Kamp , +.An Jonathan Lemon , +.An Kirk McKusick , +.An Dag-Erling Sm\(/orgrav . +.Pp +Additional contributors include: +.An Pawel Dawidek , +.An Chris Faulhaber , +.An Ilmar Habibulin , +.An Mike Halderman , +.An Bosko Milekic , +.An Thomas Moestl , +.An Andrew Reiter , +and +.An Tim Robbins . +.Sh BUGS +See the earlier section in this document concerning appropriateness +for production use. +The +.Tn TrustedBSD +MAC Framework is considered experimental in +.Fx . +.Pp +While the MAC Framework design is intended to support the containment of +the root user, not all attack channels are currently protected by entry +point checks. +As such, MAC Framework policies should not be relied on, in isolation, +to protect against a malicious privileged user. diff --git a/share/man/man9/sbuf.9 b/share/man/man9/sbuf.9 new file mode 100644 index 0000000..19a5cbe --- /dev/null +++ b/share/man/man9/sbuf.9 @@ -0,0 +1,380 @@ +.\"- +.\" Copyright (c) 2000 Poul Henning Kamp and Dag-Erling Coïdan Smørgrav +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: sbuf.9,v 1.26 2006/09/18 15:24:20 ru Exp $ +.\" +.Dd July 9, 2004 +.Dt SBUF 9 +.Os +.Sh NAME +.Nm sbuf , +.Nm sbuf_new , +.Nm sbuf_clear , +.Nm sbuf_setpos , +.Nm sbuf_bcat , +.Nm sbuf_bcopyin , +.Nm sbuf_bcpy , +.Nm sbuf_cat , +.Nm sbuf_copyin , +.Nm sbuf_cpy , +.Nm sbuf_printf , +.Nm sbuf_vprintf , +.Nm sbuf_putc , +.Nm sbuf_trim , +.Nm sbuf_overflowed , +.Nm sbuf_finish , +.Nm sbuf_data , +.Nm sbuf_len , +.Nm sbuf_done , +.Nm sbuf_delete +.Nd safe string formatting +.Sh SYNOPSIS +.In sys/types.h +.In sys/sbuf.h +.Ft struct sbuf * +.Fn sbuf_new "struct sbuf *s" "char *buf" "int length" "int flags" +.Ft void +.Fn sbuf_clear "struct sbuf *s" +.Ft int +.Fn sbuf_setpos "struct sbuf *s" "int pos" +.Ft int +.Fn sbuf_bcat "struct sbuf *s" "const void *buf" "size_t len" +.Ft int +.Fn sbuf_bcopyin "struct sbuf *s" "const void *uaddr" "size_t len" +.Ft int +.Fn sbuf_bcpy "struct sbuf *s" "const void *buf" "size_t len" +.Ft int +.Fn sbuf_cat "struct sbuf *s" "const char *str" +.Ft int +.Fn sbuf_copyin "struct sbuf *s" "const void *uaddr" "size_t len" +.Ft int +.Fn sbuf_cpy "struct sbuf *s" "const char *str" +.Ft int +.Fn sbuf_printf "struct sbuf *s" "const char *fmt" "..." +.Ft int +.Fn sbuf_vprintf "struct sbuf *s" "const char *fmt" "va_list ap" +.Ft int +.Fn sbuf_putc "struct sbuf *s" "int c" +.Ft int +.Fn sbuf_trim "struct sbuf *s" +.Ft int +.Fn sbuf_overflowed "struct sbuf *s" +.Ft void +.Fn sbuf_finish "struct sbuf *s" +.Ft char * +.Fn sbuf_data "struct sbuf *s" +.Ft int +.Fn sbuf_len "struct sbuf *s" +.Ft int +.Fn sbuf_done "struct sbuf *s" +.Ft void +.Fn sbuf_delete "struct sbuf *s" +.Sh DESCRIPTION +The +.Nm +family of functions allows one to safely allocate, construct and +release bounded null-terminated strings in kernel space. +Instead of arrays of characters, these functions operate on structures +called +.Fa sbufs , +defined in +.In sys/sbuf.h . +.Pp +The +.Fn sbuf_new +function initializes the +.Fa sbuf +pointed to by its first argument. +If that pointer is +.Dv NULL , +.Fn sbuf_new +allocates a +.Vt struct sbuf +using +.Xr malloc 9 . +The +.Fa buf +argument is a pointer to a buffer in which to store the actual string; +if it is +.Dv NULL , +.Fn sbuf_new +will allocate one using +.Xr malloc 9 . +The +.Fa length +is the initial size of the storage buffer. +The fourth argument, +.Fa flags , +may be comprised of the following flags: +.Bl -tag -width ".Dv SBUF_AUTOEXTEND" +.It Dv SBUF_FIXEDLEN +The storage buffer is fixed at its initial size. +Attempting to extend the sbuf beyond this size results in an overflow condition. +.It Dv SBUF_AUTOEXTEND +This indicates that the storage buffer may be extended as necessary, so long +as resources allow, to hold additional data. +.El +.Pp +Note that if +.Fa buf +is not +.Dv NULL , +it must point to an array of at least +.Fa length +characters. +The result of accessing that array directly while it is in use by the +sbuf is undefined. +.Pp +The +.Fn sbuf_delete +function clears the +.Fa sbuf +and frees any memory allocated for it. +There must be a call to +.Fn sbuf_delete +for every call to +.Fn sbuf_new . +Any attempt to access the sbuf after it has been deleted will fail. +.Pp +The +.Fn sbuf_clear +function invalidates the contents of the +.Fa sbuf +and resets its position to zero. +.Pp +The +.Fn sbuf_setpos +function sets the +.Fa sbuf Ns 's +end position to +.Fa pos , +which is a value between zero and one less than the size of the +storage buffer. +This effectively truncates the sbuf at the new position. +.Pp +The +.Fn sbuf_bcat +function appends the first +.Fa len +bytes from the buffer +.Fa buf +to the +.Fa sbuf . +.Pp +The +.Fn sbuf_bcopyin +function copies +.Fa len +bytes from the specified userland address into the +.Fa sbuf . +.Pp +The +.Fn sbuf_bcpy +function replaces the contents of the +.Fa sbuf +with the first +.Fa len +bytes from the buffer +.Fa buf . +.Pp +The +.Fn sbuf_cat +function appends the NUL-terminated string +.Fa str +to the +.Fa sbuf +at the current position. +.Pp +The +.Fn sbuf_copyin +function copies a NUL-terminated string from the specified userland +address into the +.Fa sbuf . +If the +.Fa len +argument is non-zero, no more than +.Fa len +characters (not counting the terminating NUL) are copied; otherwise +the entire string, or as much of it as can fit in the +.Fa sbuf , +is copied. +.Pp +The +.Fn sbuf_cpy +function replaces the contents of the +.Fa sbuf +with those of the NUL-terminated string +.Fa str . +This is equivalent to calling +.Fn sbuf_cat +with a fresh +.Fa sbuf +or one which position has been reset to zero with +.Fn sbuf_clear +or +.Fn sbuf_setpos . +.Pp +The +.Fn sbuf_printf +function formats its arguments according to the format string pointed +to by +.Fa fmt +and appends the resulting string to the +.Fa sbuf +at the current position. +.Pp +The +.Fn sbuf_vprintf +function behaves the same as +.Fn sbuf_printf +except that the arguments are obtained from the variable-length argument list +.Fa ap . +.Pp +The +.Fn sbuf_putc +function appends the character +.Fa c +to the +.Fa sbuf +at the current position. +.Pp +The +.Fn sbuf_trim +function removes trailing whitespace from the +.Fa sbuf . +.Pp +The +.Fn sbuf_overflowed +function returns a non-zero value if the +.Fa sbuf +overflowed. +.Pp +The +.Fn sbuf_finish +function null-terminates the +.Fa sbuf +and marks it as finished, which means that it may no longer be +modified using +.Fn sbuf_setpos , +.Fn sbuf_cat , +.Fn sbuf_cpy , +.Fn sbuf_printf +or +.Fn sbuf_putc . +.Pp +The +.Fn sbuf_data +and +.Fn sbuf_len +functions return the actual string and its length, respectively; +.Fn sbuf_data +only works on a finished +.Fa sbuf . +.Fn sbuf_done +returns non-zero if the sbuf is finished. +.Sh NOTES +If an operation caused an +.Fa sbuf +to overflow, most subsequent operations on it will fail until the +.Fa sbuf +is finished using +.Fn sbuf_finish +or reset using +.Fn sbuf_clear , +or its position is reset to a value between 0 and one less than the +size of its storage buffer using +.Fn sbuf_setpos , +or it is reinitialized to a sufficiently short string using +.Fn sbuf_cpy . +.Sh RETURN VALUES +The +.Fn sbuf_new +function returns +.Dv NULL +if it failed to allocate a storage buffer, and a pointer to the new +.Fa sbuf +otherwise. +.Pp +The +.Fn sbuf_setpos +function returns \-1 if +.Fa pos +was invalid, and zero otherwise. +.Pp +The +.Fn sbuf_cat , +.Fn sbuf_cpy , +.Fn sbuf_printf , +.Fn sbuf_putc , +and +.Fn sbuf_trim +functions +all return \-1 if the buffer overflowed, and zero otherwise. +.Pp +The +.Fn sbuf_overflowed +function +returns a non-zero value if the buffer overflowed, and zero otherwise. +.Pp +The +.Fn sbuf_data +and +.Fn sbuf_len +functions return +.Dv NULL +and \-1, respectively, if the buffer overflowed. +.Pp +The +.Fn sbuf_copyin +function +returns \-1 if copying string from userland failed, and number of bytes +copied otherwise. +.Sh SEE ALSO +.Xr printf 3 , +.Xr strlcat 3 , +.Xr strlcpy 3 , +.Xr copyin 9 , +.Xr copyinstr 9 , +.Xr printf 9 +.Sh HISTORY +The +.Nm +family of functions first appeared in +.Fx 4.4 . +.Sh AUTHORS +.An -nosplit +The +.Nm +family of functions was designed by +.An Poul-Henning Kamp Aq phk@FreeBSD.org +and implemented by +.An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org . +Additional improvements were suggested by +.An Justin T. Gibbs Aq gibbs@FreeBSD.org . +Auto-extend support added by +.An Kelly Yancey Aq kbyanc@FreeBSD.org . +.Pp +This manual page was written by +.An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org . diff --git a/share/man/man9/vfs_extattr.9 b/share/man/man9/vfs_extattr.9 new file mode 100644 index 0000000..f3325c1 --- /dev/null +++ b/share/man/man9/vfs_extattr.9 @@ -0,0 +1,91 @@ +.\" +.\" Copyright (c) 1999, 2000, 2001, 2003 Robert N. M. Watson +.\" 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD: extattr.9,v 1.17 2007/03/06 08:13:21 mckusick Exp $ +.\" +.Dd December 23, 1999 +.Os +.Dt VFS_EXTATTR 9 +.Sh NAME +.Nm vfs_extattr +.Nd VFS extended attributes +.Sh DESCRIPTION +The +.Nm +suite of functions allow additional metadata to be associated with vnodes +representing files, directories and symbolic links. +.Pp +The semantics of this additional data are that of a "name, value" pair, where +a name may be defined or undefined, and if defined, associated with zero or +more bytes of arbitrary binary data. +.Pp +Extended attribute names exist within a set of namespaces. Each operation +on an extended attribute is required to provide the namespace to which the +operation refers. +.Pp +If the same name is present in multiple namespaces, the extended attributes +associated with the names are stored and manipulated independently. +.Pp +Two namespaces are defined universally: +.Dv EXTATTR_NAMESPACE_USER and +.Dv EXTATTR_NAMESPACE_SYSTEM . +Individual file systems may implement additional namespaces. +.Pp +The semantics of these attributes are intended to be as follows: +.Pp +.Dv EXTATTR_NAMESPACE_USER +attribute data is protected according the normal discretionary +and mandatory protections associated with the data in the file or +directory. +.Pp +.Dv EXATTR_NAMESPACE_SYSTEM +system attribute data is protected such that appropriate privilege is required +to directly access or manipulate these attributes. +.Sh ACTIVATION +In +.Ox , +extended attributes functionality can be turned on for FFS2 by enabling the +.Dv FFS2_EXTATTR +option and compiling a new kernel. See +.Xr options 9 +for instructions. +.Sh CAVEATS +As there are a plethora of file systems with differing extended attributes, +availability and functionality of these functions may be limited, and they +should be used with awareness of the underlying semantics of the supporting +file system. +.Pp +Authorization schemes for extended attribute data may also vary by file +system, as well as maximum attribute size, and whether or not any or +specific new attributes may be defined. +.Pp +Extended attributes are named using a null-terminated character string. +Depending on underlying file system semantics, this name may or may not be +case-sensitive. +.Sh SEE ALSO +.Xr vfs 9 , +.Xr VOP_GETEXTATTR 9 , +.Xr VOP_LISTEXTATTR 9 , +.Xr VOP_SETEXTATTR 9 diff --git a/sys/arch/alpha/alpha/machdep.c b/sys/arch/alpha/alpha/machdep.c index 3006100..1bda91d 100644 --- a/sys/arch/alpha/alpha/machdep.c +++ b/sys/arch/alpha/alpha/machdep.c @@ -821,7 +821,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif #undef valloc diff --git a/sys/arch/alpha/alpha/trap.c b/sys/arch/alpha/alpha/trap.c index 51677e3..4800cbe 100644 --- a/sys/arch/alpha/alpha/trap.c +++ b/sys/arch/alpha/alpha/trap.c @@ -119,6 +119,10 @@ #include #endif +#ifdef MAC +#include +#endif + void userret(struct proc *); #ifndef SMALL_KERNEL @@ -181,6 +185,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* Do any deferred user pmap operations. */ PMAP_USERRET(vm_map_pmap(&p->p_vmspace->vm_map)); diff --git a/sys/arch/amd64/amd64/machdep.c b/sys/arch/amd64/amd64/machdep.c index e7912a6..d16ab4e 100644 --- a/sys/arch/amd64/amd64/machdep.c +++ b/sys/arch/amd64/amd64/machdep.c @@ -384,7 +384,7 @@ allocsys(vaddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/amd64/include/userret.h b/sys/arch/amd64/include/userret.h index cf644e4..a1af3a5 100644 --- a/sys/arch/amd64/include/userret.h +++ b/sys/arch/amd64/include/userret.h @@ -70,6 +70,10 @@ #include #include +#ifdef MAC +#include +#endif + static __inline void userret(struct proc *); /* @@ -81,6 +85,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/arm/arm/arm32_machdep.c b/sys/arch/arm/arm/arm32_machdep.c index d84efdc..4447c94 100644 --- a/sys/arch/arm/arm/arm32_machdep.c +++ b/sys/arch/arm/arm/arm32_machdep.c @@ -456,7 +456,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/arm/arm/ast.c b/sys/arch/arm/arm/ast.c index ddf0b48..277e35f 100644 --- a/sys/arch/arm/arm/ast.c +++ b/sys/arch/arm/arm/ast.c @@ -63,6 +63,10 @@ #include #endif +#ifdef MAC +#include +#endif + /* * Prototypes */ @@ -76,6 +80,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* Take pending signals. */ while ((sig = (CURSIG(p))) != 0) postsig(sig); diff --git a/sys/arch/aviion/aviion/machdep.c b/sys/arch/aviion/aviion/machdep.c index e6413b1..aa6abb0 100644 --- a/sys/arch/aviion/aviion/machdep.c +++ b/sys/arch/aviion/aviion/machdep.c @@ -354,7 +354,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/hp300/hp300/machdep.c b/sys/arch/hp300/hp300/machdep.c index 1d257b8..5efaa93 100644 --- a/sys/arch/hp300/hp300/machdep.c +++ b/sys/arch/hp300/hp300/machdep.c @@ -381,7 +381,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/hp300/hp300/trap.c b/sys/arch/hp300/hp300/trap.c index 0a213b7..c1632d2 100644 --- a/sys/arch/hp300/hp300/trap.c +++ b/sys/arch/hp300/hp300/trap.c @@ -103,6 +103,10 @@ extern struct emul emul_hpux; extern struct emul emul_sunos; #endif +#ifdef MAC +#include +#endif + int writeback(struct frame *); void trap(int type, u_int code, u_int v, struct frame frame); void syscall(register_t code, struct frame frame); @@ -200,6 +204,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/hppa/hppa/machdep.c b/sys/arch/hppa/hppa/machdep.c index 6e54ee8..e0cd0d5 100644 --- a/sys/arch/hppa/hppa/machdep.c +++ b/sys/arch/hppa/hppa/machdep.c @@ -398,7 +398,7 @@ hppa_init(start) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif #undef valloc v = round_page(v); diff --git a/sys/arch/hppa/hppa/trap.c b/sys/arch/hppa/hppa/trap.c index 0459f1f..11f28c2 100644 --- a/sys/arch/hppa/hppa/trap.c +++ b/sys/arch/hppa/hppa/trap.c @@ -57,6 +57,10 @@ int pcxs_unaligned(u_int opcode, vaddr_t va); void ss_clear_breakpoints(struct proc *p); #endif +#ifdef MAC +#include +#endif + /* single-step breakpoint */ #define SSBREAKPOINT (HPPA_BREAK_KERNEL | (HPPA_BREAK_SS << 13)) @@ -136,6 +140,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + if (astpending) { astpending = 0; uvmexp.softs++; diff --git a/sys/arch/hppa64/hppa64/machdep.c b/sys/arch/hppa64/hppa64/machdep.c index 292be5b..af7af81 100644 --- a/sys/arch/hppa64/hppa64/machdep.c +++ b/sys/arch/hppa64/hppa64/machdep.c @@ -275,7 +275,7 @@ TODO hpmc/toc/pfr valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #undef valloc v = round_page(v); bzero ((void *)start, (v - start)); diff --git a/sys/arch/hppa64/hppa64/trap.c b/sys/arch/hppa64/hppa64/trap.c index 0e7fa57..a3a331d 100644 --- a/sys/arch/hppa64/hppa64/trap.c +++ b/sys/arch/hppa64/hppa64/trap.c @@ -44,6 +44,10 @@ #endif #endif +#ifdef MAC +#include +#endif + const char *trap_type[] = { "invalid", "HPMC", @@ -120,6 +124,11 @@ userret(struct proc *p, register_t pc, u_quad_t oticks) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/i386/i386/conf.c b/sys/arch/i386/i386/conf.c index 4463e3e..b453872 100644 --- a/sys/arch/i386/i386/conf.c +++ b/sys/arch/i386/i386/conf.c @@ -117,6 +117,8 @@ int nblkdev = sizeof(bdevsw) / sizeof(bdevsw[0]); cdev_decl(mm); cdev_decl(wd); #include "systrace.h" +#include "eventdev.h" +#include "anoubis.h" #include "bio.h" #include "pty.h" #include "com.h" @@ -305,7 +307,9 @@ struct cdevsw cdevsw[] = cdev_bthub_init(NBTHUB,bthub), /* 86: bthub */ cdev_agp_init(NAGP,agp), /* 87: agp */ cdev_drm_init(NDRM,drm), /* 88: drm */ - cdev_amdmsr_init(NAMDMSR,amdmsr) /* 89: amdmsr */ + cdev_amdmsr_init(NAMDMSR,amdmsr), /* 89: amdmsr */ + cdev_eventdev_init(NEVENTDEV,eventdev), /* 90: Kernel Event Device */ + cdev_anoubis_init(NANOUBIS,anoubis), /* 91: Anoubis Control device */ }; int nchrdev = sizeof(cdevsw) / sizeof(cdevsw[0]); diff --git a/sys/arch/i386/i386/machdep.c b/sys/arch/i386/i386/machdep.c index 8b3568a..08c8854 100644 --- a/sys/arch/i386/i386/machdep.c +++ b/sys/arch/i386/i386/machdep.c @@ -531,7 +531,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/i386/i386/trap.c b/sys/arch/i386/i386/trap.c index 29e7c7b..3ca2bf6 100644 --- a/sys/arch/i386/i386/trap.c +++ b/sys/arch/i386/i386/trap.c @@ -94,6 +94,9 @@ extern struct emul emul_aout; #include #define KVM86MODE (kvm86_incall) #endif +#ifdef MAC +#include +#endif #include "npx.h" @@ -110,6 +113,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/luna88k/luna88k/machdep.c b/sys/arch/luna88k/luna88k/machdep.c index 6e0b23d..02f5fd4 100644 --- a/sys/arch/luna88k/luna88k/machdep.c +++ b/sys/arch/luna88k/luna88k/machdep.c @@ -536,7 +536,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/m88k/m88k/trap.c b/sys/arch/m88k/m88k/trap.c index b3e1e24..18981bd 100644 --- a/sys/arch/m88k/m88k/trap.c +++ b/sys/arch/m88k/m88k/trap.c @@ -76,6 +76,10 @@ #include +#ifdef MAC +#include +#endif + #define SSBREAKPOINT (0xF000D1F8U) /* Single Step Breakpoint */ #define USERMODE(PSR) (((PSR) & PSR_MODE) == 0) @@ -123,6 +127,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/mac68k/mac68k/machdep.c b/sys/arch/mac68k/mac68k/machdep.c index 5909c98..775a884 100644 --- a/sys/arch/mac68k/mac68k/machdep.c +++ b/sys/arch/mac68k/mac68k/machdep.c @@ -490,7 +490,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/mac68k/mac68k/trap.c b/sys/arch/mac68k/mac68k/trap.c index 725df76..a05363f 100644 --- a/sys/arch/mac68k/mac68k/trap.c +++ b/sys/arch/mac68k/mac68k/trap.c @@ -78,6 +78,10 @@ extern struct emul emul_sunos; #endif +#ifdef MAC +#include +#endif + int astpending; char *trap_type[] = { @@ -159,6 +163,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/macppc/macppc/machdep.c b/sys/arch/macppc/macppc/machdep.c index fe18fd7..56616eb 100644 --- a/sys/arch/macppc/macppc/machdep.c +++ b/sys/arch/macppc/macppc/machdep.c @@ -554,7 +554,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/mips64/mips64/interrupt.c b/sys/arch/mips64/mips64/interrupt.c index 77dbf2b..788f7e2 100644 --- a/sys/arch/mips64/mips64/interrupt.c +++ b/sys/arch/mips64/mips64/interrupt.c @@ -54,7 +54,6 @@ #include #endif - static struct evcount soft_count; static int soft_irq = 0; diff --git a/sys/arch/mips64/mips64/trap.c b/sys/arch/mips64/mips64/trap.c index 83503ff..0ee8618 100644 --- a/sys/arch/mips64/mips64/trap.c +++ b/sys/arch/mips64/mips64/trap.c @@ -92,6 +92,10 @@ #define USERMODE(ps) (((ps) & SR_KSU_MASK) == SR_KSU_USER) +#ifdef MAC +#include +#endif + struct proc *machFPCurProcPtr; /* pointer to last proc to use FP */ const char *trap_type[] = { @@ -156,6 +160,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/mvme68k/mvme68k/machdep.c b/sys/arch/mvme68k/mvme68k/machdep.c index 66602c1..f01d8e4 100644 --- a/sys/arch/mvme68k/mvme68k/machdep.c +++ b/sys/arch/mvme68k/mvme68k/machdep.c @@ -328,7 +328,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/mvme68k/mvme68k/trap.c b/sys/arch/mvme68k/mvme68k/trap.c index ef73646..1a6a6aa 100644 --- a/sys/arch/mvme68k/mvme68k/trap.c +++ b/sys/arch/mvme68k/mvme68k/trap.c @@ -97,6 +97,10 @@ extern struct emul emul_sunos; #include #endif +#ifdef MAC +#include +#endif + int astpending; int want_resched; @@ -174,6 +178,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/mvme88k/mvme88k/machdep.c b/sys/arch/mvme88k/mvme88k/machdep.c index 1bbaa9c..44d4084 100644 --- a/sys/arch/mvme88k/mvme88k/machdep.c +++ b/sys/arch/mvme88k/mvme88k/machdep.c @@ -471,7 +471,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/mvmeppc/mvmeppc/machdep.c b/sys/arch/mvmeppc/mvmeppc/machdep.c index a3913b5..130e9ff 100644 --- a/sys/arch/mvmeppc/mvmeppc/machdep.c +++ b/sys/arch/mvmeppc/mvmeppc/machdep.c @@ -466,7 +466,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/powerpc/powerpc/trap.c b/sys/arch/powerpc/powerpc/trap.c index 35e5d3d..e3142ab 100644 --- a/sys/arch/powerpc/powerpc/trap.c +++ b/sys/arch/powerpc/powerpc/trap.c @@ -61,6 +61,10 @@ #include #include +#ifdef MAC +#include +#endif + static int fix_unaligned(struct proc *p, struct trapframe *frame); int badaddr(char *addr, u_int32_t len); static __inline void userret(struct proc *); @@ -251,6 +255,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/sgi/sgi/machdep.c b/sys/arch/sgi/sgi/machdep.c index 483b9a5..2fe07ff 100644 --- a/sys/arch/sgi/sgi/machdep.c +++ b/sys/arch/sgi/sgi/machdep.c @@ -595,7 +595,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return(v); diff --git a/sys/arch/sh/include/userret.h b/sys/arch/sh/include/userret.h index dd8e22c..effb7cc 100644 --- a/sys/arch/sh/include/userret.h +++ b/sys/arch/sh/include/userret.h @@ -80,6 +80,10 @@ #include #include +#ifdef MAC +#include +#endif + static __inline void userret(struct proc *); static __inline void @@ -87,6 +91,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/sh/sh/sh_machdep.c b/sys/arch/sh/sh/sh_machdep.c index c8484af..1f24bf5 100644 --- a/sys/arch/sh/sh/sh_machdep.c +++ b/sys/arch/sh/sh/sh_machdep.c @@ -356,7 +356,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/socppc/socppc/machdep.c b/sys/arch/socppc/socppc/machdep.c index b1c73fc..d794358 100644 --- a/sys/arch/socppc/socppc/machdep.c +++ b/sys/arch/socppc/socppc/machdep.c @@ -817,7 +817,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return v; diff --git a/sys/arch/solbourne/solbourne/machdep.c b/sys/arch/solbourne/solbourne/machdep.c index 2ccc773..6537471 100644 --- a/sys/arch/solbourne/solbourne/machdep.c +++ b/sys/arch/solbourne/solbourne/machdep.c @@ -263,7 +263,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/solbourne/solbourne/trap.c b/sys/arch/solbourne/solbourne/trap.c index 47a06e3..916c361 100644 --- a/sys/arch/solbourne/solbourne/trap.c +++ b/sys/arch/solbourne/solbourne/trap.c @@ -93,6 +93,10 @@ #include #include +#ifdef MAC +#include +#endif + #ifdef DEBUG int rwindow_debug = 0; #endif @@ -221,6 +225,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/sparc/sparc/machdep.c b/sys/arch/sparc/sparc/machdep.c index 0a34886..b1a0b3f 100644 --- a/sys/arch/sparc/sparc/machdep.c +++ b/sys/arch/sparc/sparc/machdep.c @@ -291,7 +291,7 @@ allocsys(v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/sparc/sparc/trap.c b/sys/arch/sparc/sparc/trap.c index a0553bc..17ab24d 100644 --- a/sys/arch/sparc/sparc/trap.c +++ b/sys/arch/sparc/sparc/trap.c @@ -90,6 +90,10 @@ #include #include +#ifdef MAC +#include +#endif + #ifdef DEBUG int rwindow_debug = 0; #endif @@ -218,6 +222,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/sparc64/sparc64/machdep.c b/sys/arch/sparc64/sparc64/machdep.c index 78bc9ee..5a46085 100644 --- a/sys/arch/sparc64/sparc64/machdep.c +++ b/sys/arch/sparc64/sparc64/machdep.c @@ -293,7 +293,7 @@ allocsys(caddr_t v) valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); - valloc(msqids, struct msqid_ds, msginfo.msgmni); + valloc(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/sparc64/sparc64/trap.c b/sys/arch/sparc64/sparc64/trap.c index 745803e..d0c6309 100644 --- a/sys/arch/sparc64/sparc64/trap.c +++ b/sys/arch/sparc64/sparc64/trap.c @@ -88,6 +88,10 @@ #include #endif +#ifdef MAC +#include +#endif + #include #include @@ -343,6 +347,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* take pending signals */ while ((sig = CURSIG(p)) != 0) postsig(sig); diff --git a/sys/arch/vax/vax/machdep.c b/sys/arch/vax/vax/machdep.c index b7ba88f..b605ddb 100644 --- a/sys/arch/vax/vax/machdep.c +++ b/sys/arch/vax/vax/machdep.c @@ -921,7 +921,7 @@ allocsys(v) VALLOC(msgpool, char, msginfo.msgmax); VALLOC(msgmaps, struct msgmap, msginfo.msgseg); VALLOC(msghdrs, struct msg, msginfo.msgtql); - VALLOC(msqids, struct msqid_ds, msginfo.msgmni); + VALLOC(msqids, struct msqid_kernel, msginfo.msgmni); #endif return (v); diff --git a/sys/arch/vax/vax/trap.c b/sys/arch/vax/vax/trap.c index ab5bdfb..7520e68 100644 --- a/sys/arch/vax/vax/trap.c +++ b/sys/arch/vax/vax/trap.c @@ -60,6 +60,10 @@ #include #endif +#ifdef MAC +#include +#endif + #ifdef TRAPDEBUG volatile int startsysc = 0, faultdebug = 0; #endif @@ -112,6 +116,11 @@ userret(struct proc *p) { int sig; +#ifdef MAC + if (p->p_flag & P_MACPEND) + mac_proc_userret(p); +#endif + /* Take pending signals. */ while ((sig = CURSIG(p)) !=0) postsig(sig); diff --git a/sys/compat/aout/compat_aout.c b/sys/compat/aout/compat_aout.c index ca5e1b3..dfeeb28 100644 --- a/sys/compat/aout/compat_aout.c +++ b/sys/compat/aout/compat_aout.c @@ -25,6 +25,7 @@ * */ #include +#include #include #include #include diff --git a/sys/compat/common/compat_dir.c b/sys/compat/common/compat_dir.c index 84ea914..57e5aa9 100644 --- a/sys/compat/common/compat_dir.c +++ b/sys/compat/common/compat_dir.c @@ -40,6 +40,10 @@ #include +#ifdef MAC +#include +#endif + int readdir_with_callback(fp, off, nbytes, appendfunc, arg) struct file *fp; @@ -97,6 +101,13 @@ again: cookies = NULL; } +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_readdir(curproc->p_ucred, vp); + if (error) + goto out; +#endif + error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies); if (error) diff --git a/sys/compat/svr4/svr4_misc.c b/sys/compat/svr4/svr4_misc.c index e5550bf..96d0f0c 100644 --- a/sys/compat/svr4/svr4_misc.c +++ b/sys/compat/svr4/svr4_misc.c @@ -91,6 +91,10 @@ #include +#ifdef MAC +#include +#endif + static __inline clock_t timeval_to_clock_t(struct timeval *); static int svr4_setinfo(struct proc *, int, svr4_siginfo_t *); @@ -435,11 +439,21 @@ svr4_sys_fchroot(p, v, retval) error = ENOTDIR; else error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); if (error) { + VOP_UNLOCK(vp, 0, p); FRELE(fp); return error; } +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_chroot(p->p_ucred, vp); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif + VOP_UNLOCK(vp, 0, p); VREF(vp); if (fdp->fd_rdir != NULL) vrele(fdp->fd_rdir); diff --git a/sys/conf/GENERIC b/sys/conf/GENERIC index 5ec41c0..e8c65ea 100644 --- a/sys/conf/GENERIC +++ b/sys/conf/GENERIC @@ -29,6 +29,8 @@ option COMPAT_O43 # and OpenBSD 4.3 option LKM # loadable kernel modules +option ACL # Support for POSIX.1e Access Control Lists. +option EXTATTR # Support for POSIX.1e Extended Attributes. option FFS # UFS option FFS2 # UFS2 option FFS_SOFTUPDATES # Soft updates diff --git a/sys/conf/files b/sys/conf/files index 3062b05..52a0b3a 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -61,6 +61,8 @@ define rasops_rotation define atm define crypto define systrace +define eventdev +define anoubis define ether define fddi define sppp @@ -491,6 +493,8 @@ pseudo-device mpe: ifnet, ether pseudo-device sequencer pseudo-device systrace +pseudo-device eventdev +pseudo-device anoubis pseudo-device ksyms file dev/ksyms.c ksyms needs-flag @@ -572,6 +576,8 @@ file dev/midisyn.c midisyn file dev/mulaw.c mulaw file dev/sequencer.c sequencer needs-flag file dev/systrace.c systrace needs-flag +file dev/eventdev.c eventdev needs-flag +file dev/anoubis.c anoubis needs-flag file dev/vnd.c vnd needs-flag file dev/rnd.c file dev/raidframe/rf_acctrace.c raid needs-flag @@ -670,6 +676,7 @@ file kern/kern_malloc.c file kern/kern_malloc_debug.c malloc_debug file kern/kern_rwlock.c file kern/kern_physio.c +file kern/kern_priv.c file kern/kern_proc.c file kern/kern_prot.c file kern/kern_resource.c @@ -693,6 +700,7 @@ file kern/subr_evcount.c file kern/subr_extent.c file kern/subr_log.c file kern/subr_pool.c +file kern/subr_posix1e.c acl file kern/subr_prf.c file kern/subr_prof.c file kern/subr_userconf.c boot_config @@ -722,12 +730,14 @@ file kern/uipc_socket.c file kern/uipc_socket2.c file kern/uipc_syscalls.c file kern/uipc_usrreq.c +file kern/vfs_acl.c acl file kern/vfs_bio.c file kern/vfs_biomem.c file kern/vfs_cache.c file kern/vfs_cluster.c file kern/vfs_conf.c file kern/vfs_default.c +file kern/vfs_extattr.c extattr file kern/vfs_init.c file kern/vfs_lockf.c file kern/vfs_lookup.c @@ -913,6 +923,7 @@ file nfs/nfs_vfsops.c nfsclient file nfs/nfs_vnops.c nfsclient file ufs/ffs/ffs_alloc.c ffs | mfs file ufs/ffs/ffs_balloc.c ffs | mfs +file ufs/ffs/ffs_extattr.c extattr & ffs2 file ufs/ffs/ffs_inode.c ffs | mfs file ufs/ffs/ffs_subr.c ffs | mfs file ufs/ffs/ffs_softdep_stub.c ffs | mfs @@ -922,6 +933,7 @@ file ufs/ffs/ffs_vnops.c ffs | mfs file ufs/ffs/ffs_softdep.c ffs_softupdates file ufs/mfs/mfs_vfsops.c mfs file ufs/mfs/mfs_vnops.c mfs +file ufs/ufs/ufs_acl.c acl & extattr & ffs2 file ufs/ufs/ufs_bmap.c ffs | mfs | ext2fs file ufs/ufs/ufs_dirhash.c ufs_dirhash & (ffs | mfs) file ufs/ufs/ufs_ihash.c ffs | mfs | ext2fs @@ -1081,3 +1093,34 @@ file lib/libkern/arch/${MACHINE_ARCH}/skpc.S | lib/libkern/skpc.c file lib/libkern/arch/${MACHINE_ARCH}/htonl.S | lib/libkern/htonl.c file lib/libkern/arch/${MACHINE_ARCH}/htons.S | lib/libkern/htons.c file lib/libkern/arch/${MACHINE_ARCH}/strncasecmp.S | lib/libkern/strncasecmp.c +file lib/libkern/arch/${MACHINE_ARCH}/strsep.S | lib/libkern/strsep.c + +# TrustedBSD MAC framework +file security/mac/mac_cred.c mac needs-flag +file security/mac/mac_framework.c mac needs-flag +file security/mac/mac_inet.c mac needs-flag +file security/mac/mac_label.c mac needs-flag +file security/mac/mac_net.c mac needs-flag +file security/mac/mac_pipe.c mac needs-flag +file security/mac/mac_priv.c mac needs-flag +file security/mac/mac_process.c mac needs-flag +file security/mac/mac_socket.c mac needs-flag +file security/mac/mac_syscalls.c mac needs-flag +file security/mac/mac_system.c mac needs-flag +file security/mac/mac_sysv_msg.c mac needs-flag +file security/mac/mac_sysv_sem.c mac needs-flag +file security/mac/mac_sysv_shm.c mac needs-flag +file security/mac/mac_vfs.c mac needs-flag +# XXX PM: This is a multi-purpose API, but for now we only provide it if MAC +# support is enabled in the kernel. +file kern/subr_sbuf.c mac needs-flag + +# TrustedBSD test policy +file security/mac_test/mac_test.c mac_test needs-flag + +# Anoubis MAC +file security/mac_anoubis/mac_anoubis.c anoubis needs-flag +file security/mac_anoubis/mac_anoubis_alf.c anoubis needs-flag +file security/mac_anoubis/mac_anoubis_sfs.c anoubis needs-flag +file security/mac_anoubis/mac_anoubis_ipc.c anoubis needs-flag +file security/mac_anoubis/mac_anoubis_test.c anoubis needs-flag diff --git a/sys/dev/anoubis.c b/sys/dev/anoubis.c new file mode 100644 index 0000000..3c59c65 --- /dev/null +++ b/sys/dev/anoubis.c @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2007 GeNUA mbH + * + * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 COPYRIGHT + * OWNER OR CONTRIBUTORS 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +extern void anoubisattach(int); +extern int anoubisopen(dev_t, int, int, struct proc *); +extern int anoubisclose(dev_t, int, int, struct proc *); +extern int anoubisread(dev_t, struct uio *, int); +extern int anoubiswrite(dev_t, struct uio *, int); +extern int anoubisioctl(dev_t, u_long, caddr_t, int, struct proc *); +extern int ac_stats(void); +extern void ac_stats_copyone(struct anoubis_stat_value * dst, + struct anoubis_internal_stat_value * src, int cnt); + +/* ARGSUSED */ +void +anoubisattach(int n) +{ + printf("anoubis: Device registered\n"); + return; +} + +/* ARGSUSED */ +int +anoubisopen(dev_t dev, int oflags, int mode, struct proc *p) +{ + return 0; +} + +/* ARGSUSED */ +int +anoubisclose(dev_t dev, int fflag, int devtype, struct proc * p) +{ + return 0; +} + +/* ARGSUSED */ +int +anoubisread(dev_t dev, struct uio *uio, int ioflags) +{ + return EIO; +} + +/* ARGSUSED */ +int +anoubiswrite(dev_t dev, struct uio *uio, int ioflag) +{ + return EIO; +} + +/* ARGSUSED */ +int +anoubisioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, + struct proc *p) +{ + int fd; + struct file *file; + struct eventdev_queue *evq = NULL; + switch(cmd) { + case ANOUBIS_DECLARE_LISTENER: { + if (suser(p, 0) != 0) + return EPERM; + fd = (int)(*(int*)data); + file = fd_getfile(p->p_fd, fd); + if (!file) + return EBADF; + FREF(file); + evq = eventdev_get_queue(file); + FRELE(file); + if (!evq) + return EPERM; + mtx_enter(&anoubis_lock); + if (anoubis_queue != evq) { + mtx_leave(&anoubis_lock); + eventdev_put_queue(evq); + return EPERM; + } + mtx_leave(&anoubis_lock); + eventdev_put_queue(evq); + curproc->listener = 1; + return 0; + } + case ANOUBIS_DECLARE_FD: { + if (suser(p, 0) != 0) + return EPERM; + fd = (int)(*(int*)data); + file = fd_getfile(p->p_fd, fd); + if (!file) + return EBADF; + FREF(file); + evq = eventdev_get_queue(file); + FRELE(file); + if (!evq) + return EINVAL; + mtx_enter(&anoubis_lock); + if (anoubis_queue == NULL) { + anoubis_queue = evq; + evq = NULL; + } + mtx_leave(&anoubis_lock); + if (evq) { + eventdev_put_queue(evq); + return EBUSY; + } + return 0; + } + case ANOUBIS_UNDECLARE_FD: { + int ret; + if (suser(p, 0) != 0) + return EPERM; + fd = (int)(*(int*)data); + file = fd_getfile(p->p_fd, fd); + if (!file) + return EBADF; + FREF(file); + evq = eventdev_get_queue(file); + FRELE(file); + if (!evq) + return EINVAL; + mtx_enter(&anoubis_lock); + ret = EBADF; + if (anoubis_queue == evq) { + anoubis_queue = NULL; + eventdev_put_queue(evq); + ret = 0; + } + mtx_leave(&anoubis_lock); + eventdev_put_queue(evq); + return ret; + } + case ANOUBIS_REQUEST_STATS: + if (suser(p, 0) != 0) + return EPERM; + return ac_stats(); + case ANOUBIS_OLD_REPLACE_POLICY: { + static int do_print = 1; + if (do_print) { + do_print = 0; + printf("Old POLICY_REPLACE ioctl no longer " + "supported. Update your anoubisd\n"); + } + return 0; + } + case ANOUBIS_GETVERSION: + if (data == NULL) + return EINVAL; + *(unsigned long *)data = ANOUBISCORE_VERSION; + return 0; + case ANOUBIS_GETCSUM: { + struct anoubis_ioctl_csum *cs = (void*)data; + file = fd_getfile(p->p_fd, cs->fd); + if (!file) + return EBADF; + return anoubis_sfs_getcsum(file, cs->csum); + } + default: + return EIO; + } + return 0; +} + +#define ANOUBIS_STAT_FUNCS_MAX 2 + +typedef +void (*anoubis_stat_funct_t)(struct anoubis_internal_stat_value **, int*); + +anoubis_stat_funct_t anoubis_stat_funcs[ANOUBIS_STAT_FUNCS_MAX] = { + anoubis_sfs_getstats, + anoubis_alf_getstats, +}; + +void +ac_stats_copyone(struct anoubis_stat_value * dst, + struct anoubis_internal_stat_value * src, int cnt) +{ + int i; + for(i=0; ivals+total, stat, cnt); + total += cnt; + } + sz = sizeof(struct anoubis_stat_message) + + total * sizeof(struct anoubis_stat_value); + if (data == NULL) { + data = malloc(sz, M_DEVBUF, M_WAITOK); + if (!data) + return ENOMEM; + goto repeat; + } + return anoubis_notify(data, sz, ANOUBIS_SOURCE_STAT); +} diff --git a/sys/dev/anoubis.h b/sys/dev/anoubis.h new file mode 100644 index 0000000..138c62d --- /dev/null +++ b/sys/dev/anoubis.h @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2007 GeNUA mbH + * + * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 COPYRIGHT + * OWNER OR CONTRIBUTORS 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. + */ + +#ifndef _ANOUBIS_H +#define _ANOUBIS_H + +#include +#include + +#define ANOUBISCORE_VERSION 0x00010004UL + +#define ANOUBIS_CS_LEN 32 +struct anoubis_ioctl_csum { + int fd; + u_int8_t csum[ANOUBIS_CS_LEN]; +}; + +#define ANOUBIS_DECLARE_FD _IO('a',0x10) +#define ANOUBIS_DECLARE_LISTENER _IO('a',0x11) +#define ANOUBIS_REQUEST_STATS _IO('a',0x12) +#define ANOUBIS_UNDECLARE_FD _IO('a',0x13) +/* Old REPLACE_POLICY ioctl. Do not reuse. */ +#define ANOUBIS_OLD_REPLACE_POLICY _IO('a',0x14) +#define ANOUBIS_GETVERSION _IOR('a',0x15, unsigned long) +#define ANOUBIS_GETCSUM _IOWR('a',0x16, \ + struct anoubis_ioctl_csum) + +#define ANOUBIS_SOURCE_TEST 0 +#define ANOUBIS_SOURCE_ALF 10 +#define ANOUBIS_SOURCE_SANDBOX 20 +#define ANOUBIS_SOURCE_SFS 30 +#define ANOUBIS_SOURCE_SFSEXEC 31 +#define ANOUBIS_SOURCE_SFSPATH 32 +#define ANOUBIS_SOURCE_PROCESS 40 +#define ANOUBIS_SOURCE_STAT 50 +#define ANOUBIS_SOURCE_IPC 60 +#define ANOUBIS_SOURCE_PLAYGROUND 70 +#define ANOUBIS_SOURCE_PLAYGROUNDPROC 71 +#define ANOUBIS_SOURCE_PLAYGROUNDFILE 72 + +/* flags returned via anoubis_raise */ +#define ANOUBIS_RET_CLEAN(x) (x & 0xffff) +#define ANOUBIS_RET_FLAGS(x) (x & ~0xffff) +#define ANOUBIS_RET_OPEN_LOCKWATCH (1<<16) +#define ANOUBIS_RET_NEED_SECUREEXEC (1<<17) + +typedef u_int64_t anoubis_cookie_t; + +struct anoubis_event_common { + anoubis_cookie_t task_cookie; +}; + +struct anoubis_stat_value { + u_int32_t subsystem; + u_int32_t key; + u_int64_t value; +}; + +struct anoubis_stat_message { + struct anoubis_event_common common; + struct anoubis_stat_value vals[0]; +}; + +#define ANOUBIS_PROCESS_OP_FORK 0x0001UL +#define ANOUBIS_PROCESS_OP_EXIT 0x0002UL + +struct ac_process_message { + struct anoubis_event_common common; + anoubis_cookie_t task_cookie; + unsigned long op; +}; + +#define ANOUBIS_SOCKET_OP_CONNECT 0x0001UL +#define ANOUBIS_SOCKET_OP_DESTROY 0x0002UL + +struct ac_ipc_message { + struct anoubis_event_common common; + u_int32_t op; + anoubis_cookie_t source; + anoubis_cookie_t dest; + anoubis_cookie_t conn_cookie; +}; + +#ifdef _KERNEL + +#define POLICY_NOMATCH 0 +#define POLICY_MATCH 1 + +struct anoubis_internal_stat_value { + u_int32_t subsystem; + u_int32_t key; + u_int64_t * valuep; +}; + +#endif +#endif diff --git a/sys/dev/eventdev.c b/sys/dev/eventdev.c new file mode 100644 index 0000000..c5c1b45 --- /dev/null +++ b/sys/dev/eventdev.c @@ -0,0 +1,654 @@ +/* + * Copyright (c) 2008 GeNUA mbH + * + * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 COPYRIGHT + * OWNER OR CONTRIBUTORS 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +/* FIXME: Currently this stuff must not be called from IRQ-Context! */ +int eventdev_read(struct file *, off_t *, struct uio *, struct ucred *); +int eventdev_write(struct file *, off_t *, struct uio *, struct ucred *); +int eventdev_ioctl(struct file *, u_long, caddr_t, struct proc *); +int eventdev_kqfilter(struct file *, struct knote *); +int eventdev_stat(struct file *, struct stat *, struct proc *); +int eventdev_close(struct file *, struct proc *); +int eventdev_poll(struct file *, int, struct proc *); + +extern void eventdevattach(int); +extern int eventdevopen(dev_t, int, int, struct proc *); +extern int eventdevclose(dev_t, int, int, struct proc *); +extern int eventdevread(dev_t, struct uio *, int); +extern int eventdevwrite(dev_t, struct uio *, int); +extern int eventdevioctl(dev_t, u_long, caddr_t, int, struct proc *); + +TAILQ_HEAD(eventdev_list, eventdev_msg); + +/* + * Locking: The contents of messages are only accessed while the message + * is not on any list of a queue. This means that there is exactly one thread + * that has access to the message. Exceptions are the fields @link and + * @msg_reply which are protected by the queue's lock while the message + * is not private. + */ +struct eventdev_msg { + struct eventdev_hdr hdr; + char * msg_data; + TAILQ_ENTRY(eventdev_msg) link; + struct eventdev_list * list; + int msg_reply; +}; + +int eventdev_get_token(eventdev_token * tok); +void free_eventdev_msg(struct eventdev_msg * m); +int consume_reply(struct eventdev_queue * q, struct eventdev_msg * m); +int eventdev_wait(struct eventdev_queue * q, struct eventdev_msg * m); +int flush_condition(struct eventdev_queue * q); +void flush_queue(struct eventdev_queue * q); +int __eventdev_enqueue(struct eventdev_queue * q, unsigned char src, + char * data, int len, int * retval, int flags); +struct eventdev_msg * eventdev_dequeue_one(struct eventdev_queue * q); +int eventdev_copy_one(struct eventdev_queue * q, struct eventdev_msg * m, + struct uio *uio); + +struct eventdev_queue { + struct mutex lock; + unsigned int users; /* Should be an atomic_t on SMP */ + unsigned int waiters; /* # of processes in eventdev_wait */ + struct eventdev_list messages; + struct eventdev_list waiting; + struct file * file; + struct selinfo rsel; + struct selinfo wsel; +}; + +#define die_wait (&eventdev_tokenmtx) +static struct mutex eventdev_tokenmtx; /* Protects next_token below */ + +void filt_revdetach(struct knote *kn); +int filt_revent(struct knote *kn, long hint); + +void filt_wevdetach(struct knote *kn); +int filt_wevent(struct knote *kn, long hint); + +struct filterops reventdev_filtops = + { 1, NULL, filt_revdetach, filt_revent }; + +struct filterops weventdev_filtops = + { 1, NULL, filt_wevdetach, filt_wevent }; + +int +eventdev_get_token(eventdev_token * tok) +{ + static eventdev_token next_token = 0; + + mtx_enter(&eventdev_tokenmtx); + *tok = ++next_token; + mtx_leave(&eventdev_tokenmtx); + return 0; +} + +void +free_eventdev_msg(struct eventdev_msg * m) +{ + if (m->msg_data) + free(m->msg_data, M_DEVBUF); + free(m, M_DEVBUF); +} + +int +consume_reply(struct eventdev_queue * q, struct eventdev_msg * m) +{ + int ret = 0; + mtx_enter(&q->lock); + if (m->msg_reply >= 0) { + assert((m->list == &q->messages) || (m->list == &q->waiting)); + TAILQ_REMOVE(m->list, m, link); + ret = 1; + q->waiters--; + } + mtx_leave(&q->lock); + return ret; +} + +/* + * The data in @data must be allocated by the caller. + * The queue @q must be registered to receive messages from the + * message source src. + */ +int +eventdev_wait(struct eventdev_queue * q, struct eventdev_msg * m) +{ + int ret; + struct proc *p = curproc; + + while(!consume_reply(q,m)) { + if (p->p_siglist & sigmask(SIGKILL)) { + mtx_enter(&q->lock); + m->msg_reply = EINTR; + mtx_leave(&q->lock); + continue; + } + tsleep(m, PWAIT, "Eventdev reply pending", hz); + } + ret = m->msg_reply; + free_eventdev_msg(m); + wakeup(die_wait); + return ret; +} + +/* + * The caller is expected to hold a reference to the queue. This reference + * is expected to be valid after the function returns even if the function + * sleeps. Failure to follow this rule might result in warnings emitted by + * eventdev_put_queue. + * + * The return value indicates that the message was successfully enqueued. + * In all cases the buffer pointed to by data is freed. + */ + +int +__eventdev_enqueue(struct eventdev_queue * q, unsigned char src, + char * data, int len, int * retval, int flags) +{ + struct eventdev_msg * m; + int err; + + /* + * This is a small race where we might add messages to an already + * dead queue. This is harmless. + */ + if (q->file == NULL) { + free(data, M_DEVBUF); + return EPIPE; + } + m = malloc(sizeof(struct eventdev_msg), M_DEVBUF, flags); + if (!m) { + free(data, M_DEVBUF); + return ENOMEM; + } + m->hdr.msg_size = sizeof(struct eventdev_hdr) + len; + m->hdr.msg_source = src; + m->hdr.msg_flags = retval?EVENTDEV_NEED_REPLY:0; + m->hdr.msg_pid = curproc->p_pid; + m->hdr.msg_uid = curproc->p_cred->p_ruid; + m->msg_data = data; + m->msg_reply = retval?-1:0; + err = eventdev_get_token(&m->hdr.msg_token); + if (err) + goto err_out; + mtx_enter(&q->lock); + if (q->file == NULL) { + mtx_leave(&q->lock); + err = EPIPE; + goto err_out; + } + if (retval) + q->waiters++; + m->list = &q->messages; + TAILQ_INSERT_TAIL(m->list, m, link); + mtx_leave(&q->lock); + wakeup(q); + selwakeup(&q->rsel); + KNOTE(&q->rsel.si_note, 0); + if (retval) + (*retval) = eventdev_wait(q, m); + return 0; +err_out: + free(data, M_DEVBUF); + free(m, M_DEVBUF); + return err; +} + +int +eventdev_enqueue_wait(struct eventdev_queue * q, unsigned char src, + char * data, int len, int * retval, int flags) +{ + assert(retval); + return __eventdev_enqueue(q, src, data, len, retval, flags); +} + +int +eventdev_enqueue_nowait(struct eventdev_queue * q, unsigned char src, + char * data, int len, int flags) +{ + return __eventdev_enqueue(q, src, data, len, NULL, flags); +} + +struct eventdev_msg * +eventdev_dequeue_one(struct eventdev_queue * q) +{ + struct eventdev_msg * m = NULL; + + mtx_enter(&q->lock); + if (!TAILQ_EMPTY(&q->messages)) { + m = TAILQ_FIRST(&q->messages); + assert(m->list == &q->messages); + TAILQ_REMOVE(&q->messages, m, link); + } + mtx_leave(&q->lock); + return m; +} + +int +eventdev_copy_one(struct eventdev_queue * q, struct eventdev_msg * m, + struct uio *uio) +{ + size_t cnt = m->hdr.msg_size; + int err = EINVAL; + + if (cnt > uio->uio_resid) + goto fail; + err = EFAULT; + if (uiomove(&m->hdr, sizeof(struct eventdev_hdr), uio)) + goto fail; + cnt -= sizeof(struct eventdev_hdr); + if (uiomove(m->msg_data, cnt, uio)) + goto fail; + return 0; +fail: + mtx_enter(&q->lock); + m->list = &q->messages; + TAILQ_INSERT_HEAD(m->list, m, link); + mtx_leave(&q->lock); + wakeup(q); + selwakeup(&q->rsel); + KNOTE(&q->rsel.si_note, 0); + return err; +} + +int +eventdev_read(struct file *file, off_t *poff, struct uio *uio, + struct ucred *cred) +{ + struct eventdev_queue * q = file->f_data; + struct eventdev_msg * m; + int err; + + assert(q); + if (file->f_flag & FNONBLOCK) { + m = eventdev_dequeue_one(q); + if (!m) + return EAGAIN; + } else { + while(!(m = eventdev_dequeue_one(q))) { + int err = tsleep(q, PWAIT|PCATCH, "Eventdev read", hz); + if (err && err != EWOULDBLOCK) + return err; + } + } + assert(m); + /* + * eventdev_copy_one will requeue the message onto the + * q->messsages queue in case of errors. + */ + err = eventdev_copy_one(q, m, uio); + if (err) + return err; + /* + * Message successfully copied: Put it onto the list of + * messages that are waiting for a reply if necessary. + */ + if (m->msg_reply) { + assert(m->msg_reply < 0); + mtx_enter(&q->lock); + m->list = &q->waiting; + TAILQ_INSERT_TAIL(m->list, m, link); + mtx_leave(&q->lock); + } else { + free_eventdev_msg(m); + } + return 0; +} + +int +flush_condition(struct eventdev_queue * q) +{ + struct eventdev_msg * m; + int ret = 1; + + mtx_enter(&q->lock); + if (q->waiters) { + ret = 0; + TAILQ_FOREACH(m, &q->waiting, link) { + if (m->msg_reply < 0) { + m->msg_reply = EIO; + wakeup(m); + } + } + TAILQ_FOREACH(m, &q->messages, link) { + if (m->msg_reply < 0) { + m->msg_reply = EIO; + wakeup(m); + } + } + } + mtx_leave(&q->lock); + return ret; +} + +void +flush_queue(struct eventdev_queue * q) +{ + while(!flush_condition(q)) { + tsleep(die_wait, PWAIT, "Flushing eventdev queue", hz); + } +} + +void +__eventdev_get_queue(struct eventdev_queue * q) +{ + assert(q->users > 0); + q->users++; +} + +void +eventdev_put_queue(struct eventdev_queue * q) +{ + struct eventdev_msg * m; + + assert(q->users > 0); + if (--(q->users)) + return; + + assert(q->file == NULL); + /* + * NOTE: This can only happen with buggy callers of eventdev_enqueue. + * NOTE: See comment there. We try to fix up the mess. + */ + if (!TAILQ_EMPTY(&q->waiting)) { + printf("eventdev: Messages waiting on dead queue\n"); + flush_queue(q); + } + while(!TAILQ_EMPTY(&q->messages)) { + m = TAILQ_FIRST(&q->messages); + assert(m->list == &q->messages); + TAILQ_REMOVE(&q->messages, m, link); + free_eventdev_msg(m); + } + free(q, M_DEVBUF); +} + +/* ARGSUSED */ +int +eventdev_write(struct file *file, off_t *poff, struct uio *uio, + struct ucred *cred) +{ + struct eventdev_reply rep; + struct eventdev_queue * q; + struct eventdev_msg * m; + + q = file->f_data; + if (!q) + return EBADF; + if (uio->uio_resid < sizeof(struct eventdev_reply)) + return EINVAL; + if (uiomove(&rep, sizeof (struct eventdev_reply), uio)) + return EFAULT; + mtx_enter(&q->lock); + TAILQ_FOREACH(m, &q->waiting, link) { + if (m->hdr.msg_token == rep.msg_token) { + if (rep.reply >= 0) { + m->msg_reply = rep.reply; + } else { + m->msg_reply = EIO; + } + wakeup(m); + mtx_leave(&q->lock); + return 0; + } + } + mtx_leave(&q->lock); + return ESRCH; +} + +/* ARGSUSED */ +int +eventdev_ioctl(struct file *file, u_long cmd, caddr_t data, struct proc *p) +{ + return (EIO); +} + +/* ARGSUSED */ +int +eventdev_kqfilter(struct file *file, struct knote *kn) +{ + struct eventdev_queue *q = file->f_data; + struct klist *klist; + + switch (kn->kn_filter) { + case EVFILT_READ: + klist = &q->rsel.si_note; + kn->kn_fop = &reventdev_filtops; + break; + case EVFILT_WRITE: + klist = &q->wsel.si_note; + kn->kn_fop = &weventdev_filtops; + break; + default: + return (EINVAL); + } + kn->kn_hook = (void *)q; + + mtx_enter(&q->lock); + SLIST_INSERT_HEAD(klist, kn, kn_selnext); + mtx_leave(&q->lock); + + return (0); +} + +/* ARGSUSED */ +void +filt_revdetach(struct knote *kn) +{ + struct eventdev_queue *q = (struct eventdev_queue *)kn->kn_hook; + + mtx_enter(&q->lock); + SLIST_REMOVE(&q->rsel.si_note, kn, knote, kn_selnext); + mtx_leave(&q->lock); +} + +/* ARGSUSED */ +int +filt_revent(struct knote *kn, long hint) +{ + struct eventdev_queue *q = (struct eventdev_queue *)kn->kn_hook; + int ret; + + mtx_enter(&q->lock); + ret = !TAILQ_EMPTY(&q->messages); + mtx_leave(&q->lock); + + return (ret); +} + +/* ARGSUSED */ +void +filt_wevdetach(struct knote *kn) +{ + struct eventdev_queue *q = (struct eventdev_queue *)kn->kn_hook; + + mtx_enter(&q->lock); + SLIST_REMOVE(&q->wsel.si_note, kn, knote, kn_selnext); + mtx_leave(&q->lock); +} + +/* ARGSUSED */ +int +filt_wevent(struct knote *kn, long hint) +{ + return (1); +} + +/* ARGSUSED */ +int +eventdev_stat(struct file *file, struct stat *sb, struct proc *p) +{ + return (EOPNOTSUPP); +} + +/* ARGSUSED */ +int +eventdev_poll(struct file *file, int events, struct proc *p) +{ + int revents = POLLOUT|POLLWRNORM; + struct eventdev_queue * q = file->f_data; + + mtx_enter(&q->lock); + if (!TAILQ_EMPTY(&q->messages)) + revents |= (POLLIN|POLLRDNORM); + mtx_leave(&q->lock); + revents &= events; + if (revents == 0) + selrecord(p, &q->rsel); + return revents; +} + +/* ARGSUSED */ +int +eventdev_close(struct file *file, struct proc *p) +{ + struct eventdev_queue * q = file->f_data; + + assert(q); + + mtx_enter(&q->lock); + q->file = NULL; + file->f_data = NULL; + mtx_leave(&q->lock); + flush_queue(q); + eventdev_put_queue(q); + return 0; +} + +struct fileops eventdev_fops = { + eventdev_read, + eventdev_write, + eventdev_ioctl, + eventdev_poll, + eventdev_kqfilter, + eventdev_stat, + eventdev_close, +}; + +struct eventdev_queue * +eventdev_get_queue(struct file *file) +{ + struct eventdev_queue * q; + if (file->f_ops != &eventdev_fops) + return NULL; + q = file->f_data; + __eventdev_get_queue(q); + return q; +} + +/* ARGSUSED */ +void +eventdevattach(int n) +{ + mtx_init(&eventdev_tokenmtx, 0); + printf("eventdev: Device registered\n"); + return; +} + +/* ARGSUSED */ +int +eventdevopen(dev_t dev, int oflags, int mode, struct proc *p) +{ + int error, fd; + struct file * f; + struct eventdev_queue * q; + + q = malloc(sizeof(struct eventdev_queue), M_DEVBUF, M_WAITOK); + if (!q) + return ENOMEM; + mtx_init(&q->lock, IPL_SOFTNET); + TAILQ_INIT(&q->messages); + TAILQ_INIT(&q->waiting); + q->users = 1; + q->waiters = 0; + + error = falloc(p, &f, &fd); + if (error) { + free(q, M_DEVBUF); + return error; + } + q->file = f; + memset(&q->rsel, 0, sizeof(q->rsel)); + memset(&q->wsel, 0, sizeof(q->wsel)); + f->f_flag = oflags; + f->f_type = DTYPE_EVENTDEV; + f->f_ops = &eventdev_fops; + f->f_data = q; + FILE_SET_MATURE(f); + p->p_dupfd = fd; + return ENXIO; +} + +/* ARGSUSED */ +int +eventdevclose(dev_t dev, int fflag, int devtype, struct proc * p) +{ + return 0; +} + +/* ARGSUSED */ +int +eventdevread(dev_t dev, struct uio *uio, int ioflags) +{ + return 0; +} + +/* ARGSUSED */ +int +eventdevwrite(dev_t dev, struct uio *uio, int ioflag) +{ + return 0; +} + +/* ARGSUSED */ +int +eventdevioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, + struct proc *p) +{ + return 0; +} diff --git a/sys/dev/eventdev.h b/sys/dev/eventdev.h new file mode 100644 index 0000000..3c0d0a1 --- /dev/null +++ b/sys/dev/eventdev.h @@ -0,0 +1,36 @@ +#ifndef _EVENTDEV_H_ +#define _EVENTDEV_H_ + +typedef u_int32_t eventdev_token; + +#define EVENTDEV_NEED_REPLY 1 + +struct eventdev_hdr { + unsigned short msg_size; + unsigned char msg_source; + unsigned char msg_flags; + eventdev_token msg_token; + u_int32_t msg_pid; + u_int32_t msg_uid; +}; + +struct eventdev_reply { + eventdev_token msg_token; + int reply; +}; + +#ifdef _KERNEL + +struct eventdev_queue; + +extern int eventdev_enqueue_wait(struct eventdev_queue * q, unsigned char src, + char * data, int len, int * retval, int flags); +extern int eventdev_enqueue_nowait(struct eventdev_queue * q, unsigned char src, + char * data, int len, int flags); +extern struct eventdev_queue * eventdev_get_queue(struct file * file); +extern void __eventdev_get_queue(struct eventdev_queue * q); +extern void eventdev_put_queue(struct eventdev_queue * q); + +#endif /* _KERNEL */ + +#endif /* _EVENTDEV_H_ */ diff --git a/sys/dev/ic/elink3.c b/sys/dev/ic/elink3.c index d030888..c78d16d 100644 --- a/sys/dev/ic/elink3.c +++ b/sys/dev/ic/elink3.c @@ -1388,6 +1388,10 @@ epget(sc, totlen) /* Convert one of our saved mbuf's. */ sc->next_mb = (sc->next_mb + 1) % MAX_MBS; m = m_inithdr(m); +#ifdef MAC + if (m == NULL) + return (NULL); +#endif } m->m_pkthdr.rcvif = ifp; m->m_pkthdr.len = totlen; diff --git a/sys/kern/exec_aout.c b/sys/kern/exec_aout.c index d7c6ac5..498c88b 100644 --- a/sys/kern/exec_aout.c +++ b/sys/kern/exec_aout.c @@ -124,7 +124,7 @@ exec_aout_prep_zmagic(struct proc *p, struct exec_package *epp) * reasons */ if ((execp->a_text != 0 || execp->a_data != 0) && - epp->ep_vp->v_writecount != 0) { + (epp->ep_vp->v_writecount || epp->ep_vp->v_uvm.u_writecount)) { #ifdef DIAGNOSTIC if (epp->ep_vp->v_flag & VTEXT) panic("exec: a VTEXT vnode has writecount != 0"); diff --git a/sys/kern/exec_ecoff.c b/sys/kern/exec_ecoff.c index a05cf01..c4287c3 100644 --- a/sys/kern/exec_ecoff.c +++ b/sys/kern/exec_ecoff.c @@ -183,7 +183,7 @@ exec_ecoff_prep_zmagic(struct proc *p, struct exec_package *epp) * reasons */ if ((eap->tsize != 0 || eap->dsize != 0) && - epp->ep_vp->v_writecount != 0) { + (epp->ep_vp->v_writecount || epp->ep_vp->v_uvm.u_writecount)) { #ifdef DIAGNOSTIC if (epp->ep_vp->v_flag & VTEXT) panic("exec: a VTEXT vnode has writecount != 0"); diff --git a/sys/kern/exec_elf.c b/sys/kern/exec_elf.c index 5c29fb7..c2e623e 100644 --- a/sys/kern/exec_elf.c +++ b/sys/kern/exec_elf.c @@ -104,6 +104,10 @@ #include #endif +#ifdef MAC +#include +#endif + struct ELFNAME(probe_entry) { int (*func)(struct proc *, struct exec_package *, char *, u_long *, u_int8_t *); @@ -486,6 +490,11 @@ ELFNAME(load_file)(struct proc *p, char *path, struct exec_package *epp, } } +#ifdef MAC + if (path && epp->ep_interp) + mac_execve_interpreter_enter(nd.ni_vp, &epp->ep_interlabel); +#endif + vn_marktext(nd.ni_vp); bad1: @@ -530,7 +539,7 @@ ELFNAME2(exec,makecmds)(struct proc *p, struct exec_package *epp) * check if vnode is in open for writing, because we want to demand- * page out of it. if it is, don't do it, for various reasons. */ - if (epp->ep_vp->v_writecount != 0) { + if (epp->ep_vp->v_writecount || epp->ep_vp->v_uvm.u_writecount) { #ifdef DIAGNOSTIC if (epp->ep_vp->v_flag & VTEXT) panic("exec: a VTEXT vnode has writecount != 0"); diff --git a/sys/kern/exec_subr.c b/sys/kern/exec_subr.c index 487011e..ef548e9 100644 --- a/sys/kern/exec_subr.c +++ b/sys/kern/exec_subr.c @@ -205,8 +205,8 @@ vmcmd_map_pagedvn(p, cmd) error = uvm_map(&p->p_vmspace->vm_map, &cmd->ev_addr, cmd->ev_len, uobj, cmd->ev_offset, 0, - UVM_MAPFLAG(cmd->ev_prot, VM_PROT_ALL, UVM_INH_COPY, - UVM_ADV_NORMAL, UVM_FLAG_COPYONW|UVM_FLAG_FIXED)); + UVM_MAPFLAG(cmd->ev_prot, VM_PROT_ALL, UVM_INH_COPY, UVM_ADV_NORMAL, + UVM_FLAG_COPYONW|UVM_FLAG_FIXED|UVM_FLAG_DENYWRITE)); /* * check for error diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c index 0a1ea17..22c73e8 100644 --- a/sys/kern/init_main.c +++ b/sys/kern/init_main.c @@ -1,4 +1,4 @@ -/* $OpenBSD: deraadt $ */ +/* $OpenBSD: init_main.c,v 1.144 2007/09/10 18:49:45 miod Exp $ */ /* $NetBSD: init_main.c,v 1.84.4.1 1996/06/02 09:08:06 mrg Exp $ */ /* @@ -95,6 +95,10 @@ #include #endif +#if defined(MAC) +#include +#endif + #if defined(NFSSERVER) || defined(NFSCLIENT) extern void nfs_init(void); #endif @@ -253,6 +257,16 @@ main(void *framep) */ kqueue_init(); +#if defined(MAC) + /* Initialize MAC framework. */ + mac_init(); +#endif + +#ifdef ACL + /* Initialize ACL framework. */ + acl_init(); +#endif + /* * Create process 0 (the swapper). */ @@ -290,6 +304,10 @@ main(void *framep) p->p_ucred = crget(); p->p_ucred->cr_ngroups = 1; /* group 0 */ +#ifdef MAC + mac_cred_create_swapper(p->p_ucred); +#endif + /* Initialize signal state for process 0. */ signal_init(); p->p_sigacts = &sigacts0; @@ -593,6 +611,10 @@ start_init(void *arg) * Now in process 1. */ +#ifdef MAC + mac_cred_create_init(p->p_ucred); +#endif + /* * Wait for main() to tell us that it's safe to exec. */ diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c index f239a2c..aeb1e6a 100644 --- a/sys/kern/init_sysent.c +++ b/sys/kern/init_sysent.c @@ -1,10 +1,10 @@ -/* $OpenBSD: deraadt $ */ +/* $OpenBSD$ */ /* * System call switch table. * * DO NOT EDIT-- this file is automatically generated. - * created from; OpenBSD: syscalls.master,v 1.93 2009/06/03 15:42:03 jj Exp + * created from; OpenBSD: jj */ #include @@ -727,19 +727,19 @@ struct sysent sysent[] = { { 3, s(struct sys_getpeereid_args), 0, sys_getpeereid }, /* 273 = getpeereid */ { 0, 0, 0, - sys_nosys }, /* 274 = unimplemented sys_extattrctl */ + sys_nosys }, /* 274 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 275 = unimplemented sys_extattr_set_file */ + sys_nosys }, /* 275 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 276 = unimplemented sys_extattr_get_file */ + sys_nosys }, /* 276 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 277 = unimplemented sys_extattr_delete_file */ + sys_nosys }, /* 277 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 278 = unimplemented sys_extattr_set_fd */ + sys_nosys }, /* 278 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 279 = unimplemented sys_extattr_get_fd */ + sys_nosys }, /* 279 = unimplemented */ { 0, 0, 0, - sys_nosys }, /* 280 = unimplemented sys_extattr_delete_fd */ + sys_nosys }, /* 280 = unimplemented */ { 3, s(struct sys_getresuid_args), 0, sys_getresuid }, /* 281 = getresuid */ { 3, s(struct sys_setresuid_args), 0, @@ -836,5 +836,155 @@ struct sysent sysent[] = { sys_fstatfs }, /* 308 = fstatfs */ { 2, s(struct sys_fhstatfs_args), 0, sys_fhstatfs }, /* 309 = fhstatfs */ +#ifdef EXTATTR + { 5, s(struct sys_extattr_set_fd_args), 0, + sys_extattr_set_fd }, /* 310 = extattr_set_fd */ + { 5, s(struct sys_extattr_get_fd_args), 0, + sys_extattr_get_fd }, /* 311 = extattr_get_fd */ + { 3, s(struct sys_extattr_delete_fd_args), 0, + sys_extattr_delete_fd }, /* 312 = extattr_delete_fd */ + { 5, s(struct sys_extattr_set_link_args), 0, + sys_extattr_set_link }, /* 313 = extattr_set_link */ + { 5, s(struct sys_extattr_get_link_args), 0, + sys_extattr_get_link }, /* 314 = extattr_get_link */ + { 3, s(struct sys_extattr_delete_link_args), 0, + sys_extattr_delete_link }, /* 315 = extattr_delete_link */ + { 4, s(struct sys_extattr_list_fd_args), 0, + sys_extattr_list_fd }, /* 316 = extattr_list_fd */ + { 4, s(struct sys_extattr_list_file_args), 0, + sys_extattr_list_file }, /* 317 = extattr_list_file */ + { 4, s(struct sys_extattr_list_link_args), 0, + sys_extattr_list_link }, /* 318 = extattr_list_link */ + { 5, s(struct sys_extattrctl_args), 0, + sys_extattrctl }, /* 319 = extattrctl */ + { 5, s(struct sys_extattr_set_file_args), 0, + sys_extattr_set_file }, /* 320 = extattr_set_file */ + { 5, s(struct sys_extattr_get_file_args), 0, + sys_extattr_get_file }, /* 321 = extattr_get_file */ + { 5, s(struct sys_extattr_delete_file_args), 0, + sys_extattr_delete_file }, /* 322 = extattr_delete_file */ +#else + { 0, 0, 0, + sys_nosys }, /* 310 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 311 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 312 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 313 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 314 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 315 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 316 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 317 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 318 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 319 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 320 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 321 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 322 = unimplemented */ +#endif +#ifdef ACL + { 3, s(struct sys___acl_get_file_args), 0, + sys___acl_get_file }, /* 323 = __acl_get_file */ + { 3, s(struct sys___acl_set_file_args), 0, + sys___acl_set_file }, /* 324 = __acl_set_file */ + { 3, s(struct sys___acl_get_fd_args), 0, + sys___acl_get_fd }, /* 325 = __acl_get_fd */ + { 3, s(struct sys___acl_set_fd_args), 0, + sys___acl_set_fd }, /* 326 = __acl_set_fd */ + { 2, s(struct sys___acl_delete_file_args), 0, + sys___acl_delete_file }, /* 327 = __acl_delete_file */ + { 2, s(struct sys___acl_delete_fd_args), 0, + sys___acl_delete_fd }, /* 328 = __acl_delete_fd */ + { 3, s(struct sys___acl_aclcheck_file_args), 0, + sys___acl_aclcheck_file }, /* 329 = __acl_aclcheck_file */ + { 3, s(struct sys___acl_aclcheck_fd_args), 0, + sys___acl_aclcheck_fd }, /* 330 = __acl_aclcheck_fd */ + { 3, s(struct sys___acl_get_link_args), 0, + sys___acl_get_link }, /* 331 = __acl_get_link */ + { 3, s(struct sys___acl_set_link_args), 0, + sys___acl_set_link }, /* 332 = __acl_set_link */ + { 2, s(struct sys___acl_delete_link_args), 0, + sys___acl_delete_link }, /* 333 = __acl_delete_link */ + { 3, s(struct sys___acl_aclcheck_link_args), 0, + sys___acl_aclcheck_link }, /* 334 = __acl_aclcheck_link */ +#else + { 0, 0, 0, + sys_nosys }, /* 323 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 324 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 325 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 326 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 327 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 328 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 329 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 330 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 331 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 332 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 333 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 334 = unimplemented */ +#endif +#ifdef MAC + { 2, s(struct sys___mac_get_pid_args), 0, + sys___mac_get_pid }, /* 335 = __mac_get_pid */ + { 1, s(struct sys___mac_get_proc_args), 0, + sys___mac_get_proc }, /* 336 = __mac_get_proc */ + { 1, s(struct sys___mac_set_proc_args), 0, + sys___mac_set_proc }, /* 337 = __mac_set_proc */ + { 2, s(struct sys___mac_get_fd_args), 0, + sys___mac_get_fd }, /* 338 = __mac_get_fd */ + { 2, s(struct sys___mac_get_file_args), 0, + sys___mac_get_file }, /* 339 = __mac_get_file */ + { 2, s(struct sys___mac_get_link_args), 0, + sys___mac_get_link }, /* 340 = __mac_get_link */ + { 2, s(struct sys___mac_set_fd_args), 0, + sys___mac_set_fd }, /* 341 = __mac_set_fd */ + { 2, s(struct sys___mac_set_file_args), 0, + sys___mac_set_file }, /* 342 = __mac_set_file */ + { 2, s(struct sys___mac_set_link_args), 0, + sys___mac_set_link }, /* 343 = __mac_set_link */ + { 3, s(struct sys_mac_syscall_args), 0, + sys_mac_syscall }, /* 344 = mac_syscall */ +#else + { 0, 0, 0, + sys_nosys }, /* 335 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 336 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 337 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 338 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 339 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 340 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 341 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 342 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 343 = unimplemented */ + { 0, 0, 0, + sys_nosys }, /* 344 = unimplemented */ +#endif + /* NUMBER OF SYSCALLS: 344 */ }; diff --git a/sys/kern/kern_acct.c b/sys/kern/kern_acct.c index 0cb23e2..58f0aab 100644 --- a/sys/kern/kern_acct.c +++ b/sys/kern/kern_acct.c @@ -56,6 +56,10 @@ #include +#ifdef MAC +#include +#endif + /* * The routines implemented in this file are described in: * Leffler, et al.: The Design and Implementation of the 4.3BSD @@ -116,11 +120,27 @@ sys_acct(struct proc *p, void *v, register_t *retval) p); if ((error = vn_open(&nd, FWRITE|O_APPEND, 0)) != 0) return (error); - VOP_UNLOCK(nd.ni_vp, 0, p); if (nd.ni_vp->v_type != VREG) { + VOP_UNLOCK(nd.ni_vp, 0, p); vn_close(nd.ni_vp, FWRITE, p->p_ucred, p); return (EACCES); } +#ifdef MAC + /* XXX PM: nd.ni_vp is locked. */ + error = mac_system_check_acct(p->p_ucred, nd.ni_vp); + if (error) { + VOP_UNLOCK(nd.ni_vp, 0, p); + vn_close(nd.ni_vp, FWRITE, p->p_ucred, p); + return (error); + } +#endif + VOP_UNLOCK(nd.ni_vp, 0, p); +#ifdef MAC + } else { + error = mac_system_check_acct(p->p_ucred, NULL); + if (error) + return (error); +#endif } /* diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c index a46cec1..e3d0ad9 100644 --- a/sys/kern/kern_descrip.c +++ b/sys/kern/kern_descrip.c @@ -64,6 +64,10 @@ #include +#ifdef MAC +#include +#endif + /* * Descriptor management. */ @@ -430,6 +434,11 @@ restart: error = EBADF; goto out; } +#ifdef ANOUBIS + error = mac_vnode_check_lock(p->p_ucred, vp, fl.l_type); + if (error) + goto out; +#endif atomic_setbits_int(&fdp->fd_flags, FD_ADVLOCK); error = VOP_ADVLOCK(vp, fdp, F_SETLK, &fl, flg); break; @@ -439,11 +448,21 @@ restart: error = EBADF; goto out; } +#ifdef ANOUBIS + error = mac_vnode_check_lock(p->p_ucred, vp, fl.l_type); + if (error) + goto out; +#endif atomic_setbits_int(&fdp->fd_flags, FD_ADVLOCK); error = VOP_ADVLOCK(vp, fdp, F_SETLK, &fl, flg); break; case F_UNLCK: +#ifdef ANOUBIS + error = mac_vnode_check_lock(p->p_ucred, vp, fl.l_type); + if (error) + goto out; +#endif error = VOP_ADVLOCK(vp, fdp, F_UNLCK, &fl, F_POSIX); goto out; @@ -1082,6 +1101,17 @@ closef(struct file *fp, struct proc *p) return (0); } +#ifdef ANOUBIS + /* This should only happen for vnodes in f_data */ + if (fp->denywrite) { + struct vnode *vp; + assert(fp->f_type == DTYPE_VNODE); + vp = fp->f_data; + assert(vp->v_denywrite >= fp->denywrite); + vp->v_denywrite -= fp->denywrite; + fp->denywrite = 0; + } +#endif if (fp->f_ops) error = (*fp->f_ops->fo_close)(fp, p); else @@ -1134,6 +1164,11 @@ sys_flock(struct proc *p, void *v, register_t *retval) if (how & LOCK_UN) { lf.l_type = F_UNLCK; fp->f_flag &= ~FHASLOCK; +#ifdef ANOUBIS + error = mac_vnode_check_lock(p->p_ucred, vp, lf.l_type); + if (error) + goto out; +#endif error = VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK); goto out; } @@ -1145,6 +1180,11 @@ sys_flock(struct proc *p, void *v, register_t *retval) error = EINVAL; goto out; } +#ifdef ANOUBIS + error = mac_vnode_check_lock(p->p_ucred, vp, lf.l_type); + if (error) + goto out; +#endif fp->f_flag |= FHASLOCK; if (how & LOCK_NB) error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK); diff --git a/sys/kern/kern_event.c b/sys/kern/kern_event.c index 7ac9bf7..0b0858a 100644 --- a/sys/kern/kern_event.c +++ b/sys/kern/kern_event.c @@ -52,6 +52,10 @@ #include #include +#ifdef MAC +#include +#endif + int kqueue_scan(struct file *fp, int maxevents, struct kevent *ulistp, const struct timespec *timeout, struct proc *p, int *retval); @@ -192,11 +196,21 @@ int filt_procattach(struct knote *kn) { struct proc *p; +#ifdef MAC + int error; +#endif p = pfind(kn->kn_id); if (p == NULL) return (ESRCH); +#ifdef MAC + /* XXX PM: I'm not sure there is always a process context here. */ + error = mac_cred_check_visible(curproc->p_ucred, p->p_ucred); + if (error) + return (error); +#endif + /* * Fail if it's not owned by you, or the last exec gave us * setuid/setgid privs (unless you're root). diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c index 31fe37e..ea5a679 100644 --- a/sys/kern/kern_exec.c +++ b/sys/kern/kern_exec.c @@ -39,6 +39,7 @@ #include #include #include +#include #include #include #include @@ -72,6 +73,12 @@ #include #endif +#ifdef MAC +#include +#endif + +int do_execve(struct proc *, void *, register_t *, struct mac *); + /* * Map the shared signal code. */ @@ -113,16 +120,26 @@ check_exec(struct proc *p, struct exec_package *epp) { int error, i; struct vnode *vp; +#ifdef ANOUBIS + struct vnode *dvp = NULL; +#endif struct nameidata *ndp; size_t resid; ndp = epp->ep_ndp; ndp->ni_cnd.cn_nameiop = LOOKUP; +#ifdef ANOUBIS + ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF | SAVENAME | WANTPARENT; +#else ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF | SAVENAME; +#endif /* first get the vnode */ if ((error = namei(ndp)) != 0) return (error); epp->ep_vp = vp = ndp->ni_vp; +#ifdef ANOUBIS + dvp = ndp->ni_dvp; +#endif /* check for regular file */ if (vp->v_type == VDIR) { @@ -169,6 +186,14 @@ check_exec(struct proc *p, struct exec_package *epp) goto bad2; epp->ep_hdrvalid = epp->ep_hdrlen - resid; +#ifdef ANOUBIS + error = mac_execve_prepare(epp); + if (error) + goto bad2; + if (dvp) + vrele(dvp); + dvp = NULL; +#endif /* * set up the vmcmds for creation of the process * address space @@ -215,6 +240,10 @@ bad2: */ vn_close(vp, FREAD, p->p_ucred, p); pool_put(&namei_pool, ndp->ni_cnd.cn_pnbuf); +#ifdef ANOUBIS + if (dvp) + vrele(dvp); +#endif return (error); bad1: @@ -224,6 +253,10 @@ bad1: */ pool_put(&namei_pool, ndp->ni_cnd.cn_pnbuf); vput(vp); +#ifdef ANOUBIS + if (dvp) + vrele(dvp); +#endif return (error); } @@ -234,17 +267,23 @@ bad1: int sys_execve(struct proc *p, void *v, register_t *retval) { + return (do_execve(p, v, retval, NULL)); +} + +int +do_execve(struct proc *p, void *v, register_t *retval, struct mac *mac_p) +{ struct sys_execve_args /* { syscallarg(const char *) path; syscallarg(char *const *) argp; syscallarg(char *const *) envp; } */ *uap = v; - int error; + int credential_changing, error; struct exec_package pack; struct nameidata nid; struct vattr attr; - struct ucred *cred = p->p_ucred; - char *argp; + struct ucred *oldcred, *cred = p->p_ucred; + char *argp = NULL; char * const *cpp, *dp, *sp; long argc, envc; size_t len, sgap; @@ -261,6 +300,9 @@ sys_execve(struct proc *p, void *v, register_t *retval) ISSET(p->p_flag, P_SUGID) || ISSET(p->p_flag, P_SUGIDEXEC); size_t pathbuflen; #endif +#ifdef MAC + int will_transition; +#endif char *pathbuf = NULL; /* @@ -303,12 +345,21 @@ sys_execve(struct proc *p, void *v, register_t *retval) pack.ep_vap = &attr; pack.ep_emul = &emul_native; pack.ep_flags = 0; +#ifdef MAC + pack.ep_label = NULL; + pack.ep_interlabel = NULL; +#endif +#ifdef MAC + error = mac_execve_enter(&pack, mac_p); + if (error) + return error; +#endif /* see if we can run it. */ if ((error = check_exec(p, &pack)) != 0) { goto freehdr; } - + /* XXX -- THE FOLLOWING SECTION NEEDS MAJOR CLEANUP */ /* allocate an argument buffer */ @@ -489,7 +540,19 @@ sys_execve(struct proc *p, void *v, register_t *retval) * deal with set[ug]id. * MNT_NOEXEC has already been used to disable s[ug]id. */ - if ((attr.va_mode & (VSUID | VSGID)) && proc_cansugid(p)) { + oldcred = p->p_ucred; + credential_changing = 0; + credential_changing |= (attr.va_mode & VSUID) && oldcred->cr_uid != + attr.va_uid; + credential_changing |= (attr.va_mode & VSGID) && oldcred->cr_gid != + attr.va_gid; +#ifdef MAC + will_transition = mac_vnode_execve_will_transition(oldcred, pack.ep_vp, + pack.ep_interlabel, &pack); + credential_changing |= will_transition; +#endif + + if (credential_changing && proc_cansugid(p)) { int i; atomic_setbits_int(&p->p_flag, P_SUGID|P_SUGIDEXEC); @@ -510,6 +573,13 @@ sys_execve(struct proc *p, void *v, register_t *retval) if (attr.va_mode & VSGID) p->p_ucred->cr_gid = attr.va_gid; +#ifdef MAC + if (will_transition) { + mac_vnode_execve_transition(oldcred, p->p_ucred, + pack.ep_vp, pack.ep_interlabel, &pack); + } +#endif + /* * For set[ug]id processes, a few caveats apply to * stdin, stdout, and stderr. @@ -591,6 +661,14 @@ sys_execve(struct proc *p, void *v, register_t *retval) splx(s); } +#ifdef ANOUBIS + /* + * Do this late because mac_execve_success relies on a properly + * set P_SUGIDEXEC flag. + */ + mac_execve_success(&pack); +#endif + uvm_km_free_wakeup(exec_map, (vaddr_t) argp, NCARGS); pool_put(&namei_pool, nid.ni_cnd.cn_pnbuf); @@ -649,6 +727,13 @@ sys_execve(struct proc *p, void *v, register_t *retval) /* update p_emul, the old value is no longer needed */ p->p_emul = pack.ep_emul; + vfs_mark_atime(pack.ep_vp, p->p_ucred); + +#ifdef MAC + mac_execve_exit(&pack); + mac_execve_interpreter_exit(pack.ep_interlabel); +#endif + #ifdef KTRACE if (KTRPOINT(p, KTR_EMUL)) ktremul(p, p->p_emul->e_name); @@ -669,6 +754,9 @@ sys_execve(struct proc *p, void *v, register_t *retval) return (0); bad: +#ifdef MAC + mac_execve_exit(&pack); +#endif /* free the vmspace-creation commands, and release their references */ kill_vmcmds(&pack.ep_vmcmds); /* kill any opened file descriptor, if necessary */ @@ -683,9 +771,13 @@ bad: /* close and put the exec'd file */ vn_close(pack.ep_vp, FREAD, cred, p); pool_put(&namei_pool, nid.ni_cnd.cn_pnbuf); - uvm_km_free_wakeup(exec_map, (vaddr_t) argp, NCARGS); + if (argp != NULL) + uvm_km_free_wakeup(exec_map, (vaddr_t) argp, NCARGS); freehdr: +#ifdef MAC + mac_execve_exit(&pack); +#endif free(pack.ep_hdr, M_EXEC); #if NSYSTRACE > 0 clrflag: @@ -714,6 +806,9 @@ exec_abort: uvm_km_free_wakeup(exec_map, (vaddr_t) argp, NCARGS); free_pack_abort: +#ifdef MAC + mac_execve_exit(&pack); +#endif free(pack.ep_hdr, M_EXEC); exit1(p, W_EXITCODE(0, SIGABRT), EXIT_NORMAL); diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c index ed41093..85f2268 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -74,6 +74,15 @@ #include +#ifdef ANOUBIS +#include +#include +#endif + +#ifdef MAC +#include +#endif + /* * exit -- * Death of process. @@ -219,6 +228,15 @@ exit1(struct proc *p, int rv, int flags) #ifdef ACCOUNTING (void)acct_process(p); #endif +#ifdef ANOUBIS + { + struct ac_process_message * msg; + msg = malloc(sizeof(*msg), M_DEVBUF, M_WAITOK); + msg->op = ANOUBIS_PROCESS_OP_EXIT; + msg->task_cookie = p->task_cookie; + anoubis_notify(msg, sizeof(*msg), ANOUBIS_SOURCE_PROCESS); + } +#endif #ifdef KTRACE /* * release trace file @@ -444,6 +462,15 @@ loop: p->p_pgid != -SCARG(uap, pid))) continue; +#ifdef MAC + /* + * XXX PM: This is a little bit odd. We should return an error + * here, I believe. + */ + if (mac_proc_check_wait(curproc->p_ucred, p)) + continue; +#endif + /* * Wait for processes with p_exitsig != SIGCHLD processes only * if WALTSIG is set; wait for processes with pexitsig == @@ -571,6 +598,10 @@ proc_zap(struct proc *p) if (p->p_textvp) vrele(p->p_textvp); +#ifdef MAC + mac_proc_destroy(p); +#endif + /* * Remove us from our process list, possibly killing the process * in the process (pun intended). diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c index 89a84f0..51c1dfe 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -65,6 +65,15 @@ #include #include +#ifdef ANOUBIS +#include +#include +#endif + +#ifdef MAC +#include +#endif + int nprocs = 1; /* process 0 */ int randompid; /* when set to 1, pid's go random */ pid_t lastpid; @@ -168,6 +177,11 @@ process_new(struct proc *newproc, struct proc *parent) /* print the 'table full' message once per 10 seconds */ struct timeval fork_tfmrate = { 10, 0 }; +#ifdef ANOUBIS +anoubis_cookie_t next_task_cookie = 0; +struct mutex task_cookie_mutex; +#endif + int fork1(struct proc *p1, int exitsig, int flags, void *stack, size_t stacksize, void (*func)(void *), void *arg, register_t *retval, @@ -244,6 +258,10 @@ fork1(struct proc *p1, int exitsig, int flags, void *stack, size_t stacksize, process_new(p2, p1); #endif +#ifdef MAC + mac_proc_init(p2); +#endif + /* * Make a proc table entry for the new process. * Start by zeroing the section of proc that is zero-initialized, @@ -359,6 +377,20 @@ fork1(struct proc *p1, int exitsig, int flags, void *stack, size_t stacksize, p2->p_addr = (struct user *)uaddr; +#ifdef ANOUBIS + p2->listener = 0; + mtx_enter(&task_cookie_mutex); + p2->task_cookie = ++next_task_cookie; + mtx_leave(&task_cookie_mutex); + { + struct ac_process_message * msg; + msg = malloc(sizeof(*msg), M_DEVBUF, M_WAITOK); + msg->op = ANOUBIS_PROCESS_OP_FORK; + msg->task_cookie = p2->task_cookie; + anoubis_notify(msg, sizeof(struct ac_process_message), + ANOUBIS_SOURCE_PROCESS); + } +#endif /* * Finish creating the child process. It will return through a * different path later. diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c index af63abc..9c95eff 100644 --- a/sys/kern/kern_ktrace.c +++ b/sys/kern/kern_ktrace.c @@ -52,6 +52,10 @@ #include +#ifdef MAC +#include +#endif + void ktrinitheader(struct ktr_header *, struct proc *, int); int ktrops(struct proc *, struct proc *, int, int, struct vnode *); int ktrsetchildren(struct proc *, struct proc *, int, int, @@ -352,12 +356,18 @@ sys_ktrace(struct proc *curp, void *v, register_t *retval) error = ESRCH; goto done; } - LIST_FOREACH(p, &pg->pg_members, p_pglist) + LIST_FOREACH(p, &pg->pg_members, p_pglist) { +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, + p->p_ucred); + if (error) + goto done; +#endif if (descend) ret |= ktrsetchildren(curp, p, ops, facs, vp); else ret |= ktrops(curp, p, ops, facs, vp); - + } } else { /* * by pid @@ -367,6 +377,11 @@ sys_ktrace(struct proc *curp, void *v, register_t *retval) error = ESRCH; goto done; } +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, p->p_ucred); + if (error) + goto done; +#endif if (descend) ret |= ktrsetchildren(curp, p, ops, facs, vp); else @@ -510,7 +525,12 @@ ktrcanset(struct proc *callp, struct proc *targetp) (targetp->p_traceflag & KTRFAC_ROOT) == 0 && !ISSET(targetp->p_flag, P_SUGID)) || caller->pc_ucred->cr_uid == 0) +#ifdef MAC + if (!mac_proc_check_debug(callp->p_ucred, targetp)) + return (1); +#else return (1); +#endif return (0); } diff --git a/sys/kern/kern_priv.c b/sys/kern/kern_priv.c new file mode 100644 index 0000000..832b8e1 --- /dev/null +++ b/sys/kern/kern_priv.c @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2006 nCircle Network Security, Inc. + * All rights reserved. + * + * This software was developed by Robert N. M. Watson for the TrustedBSD + * Project under contract to nCircle Network Security, Inc. + * + * 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 AND CONTRIBUTORS ``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, NCIRCLE NETWORK SECURITY, + * INC., OR CONTRIBUTORS 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. + * + * $FreeBSD: kern_priv.c,v 1.6 2008/09/17 15:49:44 attilio Exp $ + */ + +#include +#include +#include +#include +#include +#include + +#include + +/* + * `suser_enabled' (which can be set by the security.bsd.suser_enabled + * sysctl) determines whether the system 'super-user' policy is in effect. If + * it is nonzero, an effective uid of 0 connotes special privilege, + * overriding many mandatory and discretionary protections. If it is zero, + * uid 0 is offered no special privilege in the kernel security policy. + * Setting it to zero may seriously impact the functionality of many existing + * userland programs, and should not be done without careful consideration of + * the consequences. + */ +int suser_enabled = 1; +#if 0 /* XXX PM: We won't offer suser_enabled through sysctl() in Anoubis. */ +SYSCTL_INT(_security_bsd, OID_AUTO, suser_enabled, CTLFLAG_RW, + &suser_enabled, 0, "processes with uid 0 have privilege"); +TUNABLE_INT("security.bsd.suser_enabled", &suser_enabled); +#endif + +/* + * Check a credential for privilege. Lots of good reasons to deny privilege; + * only a few to grant it. + */ +int +priv_check_cred(struct ucred *cred, int priv, int flags) +{ +#ifdef MAC + int error; +#endif + + KASSERT(PRIV_VALID(priv)); + + /* + * We first evaluate policies that may deny the granting of + * privilege unilaterally. + */ +#ifdef MAC + error = mac_priv_check(cred, priv); + if (error) + return (error); +#endif + + /* + * Jail policy will restrict certain privileges that may otherwise be + * be granted. XXX PM: Disabled, since there are no jails in OpenBSD. + */ +#if 0 + error = prison_priv_check(cred, priv); + if (error) + return (error); +#endif + + /* + * Having determined if privilege is restricted by various policies, + * now determine if privilege is granted. At this point, any policy + * may grant privilege. For now, we allow short-circuit boolean + * evaluation, so may not call all policies. Perhaps we should. + * + * Superuser policy grants privilege based on the effective (or in + * the case of specific privileges, real) uid being 0. We allow the + * superuser policy to be globally disabled, although this is + * currenty of limited utility. + */ + if (suser_enabled) { + switch (priv) { +#if 0 /* XXX PM: Unused for now. */ + case PRIV_MAXFILES: + case PRIV_MAXPROC: + case PRIV_PROC_LIMIT: + if (cred->p_ruid == 0) + return (0); + break; +#endif + default: + if (cred->cr_uid == 0) + return (0); + break; + } + } + + /* + * Now check with MAC, if enabled, to see if a policy module grants + * privilege. + */ +#ifdef MAC + if (mac_priv_grant(cred, priv) == 0) + return (0); +#endif + return (EPERM); +} + +int +priv_check(struct proc *p, int priv) +{ + + KASSERT(p == curproc); + + return (priv_check_cred(p->p_ucred, priv, 0)); +} diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c index 00a1706..7d0db5a 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -91,7 +91,9 @@ procinit(void) uihashtbl = hashinit(maxproc / 16, M_PROC, M_NOWAIT, &uihash); if (!pidhashtbl || !pgrphashtbl || !uihashtbl) panic("procinit: malloc"); - +#ifdef ANOUBIS + mtx_init(&task_cookie_mutex, 0); +#endif pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl", &pool_allocator_nointr); pool_init(&process_pool, sizeof(struct process), 0, 0, 0, "processpl", diff --git a/sys/kern/kern_prot.c b/sys/kern/kern_prot.c index b24d86f..df36282 100644 --- a/sys/kern/kern_prot.c +++ b/sys/kern/kern_prot.c @@ -55,6 +55,10 @@ #include #include +#ifdef MAC +#include +#endif + /* ARGSUSED */ int sys_getpid(struct proc *p, void *v, register_t *retval) @@ -107,11 +111,19 @@ sys_getpgid(struct proc *curp, void *v, register_t *retval) syscallarg(pid_t) pid; } */ *uap = v; struct proc *targp = curp; +#ifdef MAC + int error; +#endif if (SCARG(uap, pid) == 0 || SCARG(uap, pid) == curp->p_pid) goto found; if ((targp = pfind(SCARG(uap, pid))) == NULL) return (ESRCH); +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, targp->p_ucred); + if (error) + return (error); +#endif if (targp->p_session != curp->p_session) return (EPERM); found: @@ -126,6 +138,9 @@ sys_getsid(struct proc *curp, void *v, register_t *retval) syscallarg(pid_t) pid; } */ *uap = v; struct proc *targp = curp; +#ifdef MAC + int error; +#endif if (SCARG(uap, pid) == 0 || SCARG(uap, pid) == curp->p_pid) goto found; @@ -133,6 +148,11 @@ sys_getsid(struct proc *curp, void *v, register_t *retval) return (ESRCH); if (targp->p_session != curp->p_session) return (EPERM); +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, targp->p_ucred); + if (error) + return (error); +#endif found: /* Skip exiting processes */ if (targp->p_pgrp->pg_session->s_leader == NULL) @@ -294,6 +314,11 @@ sys_setpgid(struct proc *curp, void *v, register_t *retval) error = EACCES; goto out; } +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, targp->p_ucred); + if (error) + goto out; +#endif } else targp = curp; if (SESS_LEADER(targp)) { @@ -388,6 +413,12 @@ sys_setresuid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_setresuid(p, p->p_ucred, ruid, euid, suid); + if (error) + return (error); +#endif + /* * Note that unlike the other set*uid() calls, each * uid type is set independently of the others. @@ -488,6 +519,12 @@ sys_setresgid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_setresgid(p, p->p_ucred, rgid, egid, sgid); + if (error) + return (error); +#endif + /* * Note that unlike the other set*gid() calls, each * gid type is set independently of the others. @@ -519,10 +556,19 @@ sys_setregid(struct proc *p, void *v, register_t *retval) struct pcred *pc = p->p_cred; struct sys_setresgid_args sresgidargs; gid_t rgid, egid; +#ifdef MAC + int error; +#endif rgid = SCARG(&sresgidargs, rgid) = SCARG(uap, rgid); egid = SCARG(&sresgidargs, egid) = SCARG(uap, egid); +#ifdef MAC + error = mac_proc_check_setregid(p, p->p_ucred, rgid, egid); + if (error) + return (error); +#endif + /* * The saved gid presents a bit of a dilemma, as it did not * exist when setregid(2) was conceived. We only set the saved @@ -549,10 +595,19 @@ sys_setreuid(struct proc *p, void *v, register_t *retval) struct pcred *pc = p->p_cred; struct sys_setresuid_args sresuidargs; uid_t ruid, euid; +#ifdef MAC + int error; +#endif ruid = SCARG(&sresuidargs, ruid) = SCARG(uap, ruid); euid = SCARG(&sresuidargs, euid) = SCARG(uap, euid); +#ifdef MAC + error = mac_proc_check_setreuid(p, p->p_ucred, ruid, euid); + if (error) + return (error); +#endif + /* * The saved uid presents a bit of a dilemma, as it did not * exist when setreuid(2) was conceived. We only set the saved @@ -592,6 +647,12 @@ sys_setuid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_setuid(p, p->p_ucred, uid); + if (error) + return (error); +#endif + /* * Everything's okay, do it. */ @@ -637,6 +698,12 @@ sys_seteuid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_seteuid(p, p->p_ucred, euid); + if (error) + return (error); +#endif + /* * Copy credentials so other references do not see our changes. */ @@ -670,6 +737,12 @@ sys_setgid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_setgid(p, p->p_ucred, gid); + if (error) + return (error); +#endif + if (gid == pc->pc_ucred->cr_gid || suser(p, 0) == 0) { pc->p_rgid = gid; @@ -705,6 +778,12 @@ sys_setegid(struct proc *p, void *v, register_t *retval) (error = suser(p, 0))) return (error); +#ifdef MAC + error = mac_proc_check_setegid(p, p->p_ucred, egid); + if (error) + return (error); +#endif + /* * Copy credentials so other references do not see our changes. */ @@ -725,17 +804,31 @@ sys_setgroups(struct proc *p, void *v, register_t *retval) struct pcred *pc = p->p_cred; u_int ngrp; int error; + gid_t *kgidset; + size_t kgidsetsize; if ((error = suser(p, 0)) != 0) return (error); ngrp = SCARG(uap, gidsetsize); if (ngrp > NGROUPS) return (EINVAL); + kgidsetsize = ngrp * sizeof(gid_t); + kgidset = malloc(kgidsetsize, M_TEMP, M_WAITOK); + error = copyin(SCARG(uap, gidset), kgidset, kgidsetsize); + if (error) { + free(kgidset, M_TEMP); + return (error); + } pc->pc_ucred = crcopy(pc->pc_ucred); - error = copyin((caddr_t)SCARG(uap, gidset), - (caddr_t)pc->pc_ucred->cr_groups, ngrp * sizeof(gid_t)); - if (error) +#ifdef MAC + error = mac_proc_check_setgroups(p, p->p_ucred, ngrp, kgidset); + if (error) { + free(kgidset, M_TEMP); return (error); + } +#endif + memcpy(pc->pc_ucred->cr_groups, kgidset, kgidsetsize); + free(kgidset, M_TEMP); pc->pc_ucred->cr_ngroups = ngrp; atomic_setbits_int(&p->p_flag, P_SUGID); return (0); @@ -795,6 +888,9 @@ crget(void) cr = pool_get(&ucred_pool, PR_WAITOK|PR_ZERO); cr->cr_ref = 1; +#ifdef MAC + mac_cred_init(cr); +#endif return (cr); } @@ -806,8 +902,12 @@ void crfree(struct ucred *cr) { - if (--cr->cr_ref == 0) + if (--cr->cr_ref == 0) { +#ifdef MAC + mac_cred_destroy(cr); +#endif pool_put(&ucred_pool, cr); + } } /* @@ -821,9 +921,14 @@ crcopy(struct ucred *cr) if (cr->cr_ref == 1) return (cr); newcr = crget(); - *newcr = *cr; - crfree(cr); + bcopy(&cr->cr_startcopy, &newcr->cr_startcopy, + (unsigned)((caddr_t)&cr->cr_endcopy - + (caddr_t)&cr->cr_startcopy)); newcr->cr_ref = 1; +#ifdef MAC + mac_cred_copy(cr, newcr); +#endif + crfree(cr); return (newcr); } @@ -836,8 +941,13 @@ crdup(struct ucred *cr) struct ucred *newcr; newcr = crget(); - *newcr = *cr; + bcopy(&cr->cr_startcopy, &newcr->cr_startcopy, + (unsigned)((caddr_t)&cr->cr_endcopy - + (caddr_t)&cr->cr_startcopy)); newcr->cr_ref = 1; +#ifdef MAC + mac_cred_copy(cr, newcr); +#endif return (newcr); } diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c index ae82625..d18447f 100644 --- a/sys/kern/kern_resource.c +++ b/sys/kern/kern_resource.c @@ -51,6 +51,10 @@ #include +#ifdef MAC +#include +#endif + /* * Patchable maximum data and stack limits. */ @@ -70,6 +74,9 @@ sys_getpriority(struct proc *curp, void *v, register_t *retval) } */ *uap = v; struct proc *p; int low = NZERO + PRIO_MAX + 1; +#ifdef MAC + int error; +#endif switch (SCARG(uap, which)) { @@ -111,6 +118,11 @@ sys_getpriority(struct proc *curp, void *v, register_t *retval) } if (low == NZERO + PRIO_MAX + 1) return (ESRCH); +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, p->p_ucred); + if (error) + return (error); +#endif *retval = low - NZERO; return (0); } @@ -136,8 +148,13 @@ sys_setpriority(struct proc *curp, void *v, register_t *retval) p = pfind(SCARG(uap, who)); if (p == 0) break; - error = donice(curp, p, SCARG(uap, prio)); found++; +#ifdef MAC + error = mac_cred_check_visible(curp->p_ucred, p->p_ucred); + if (error) + break; +#endif + error = donice(curp, p, SCARG(uap, prio)); break; case PRIO_PGRP: { @@ -148,8 +165,15 @@ sys_setpriority(struct proc *curp, void *v, register_t *retval) else if ((pg = pgfind(SCARG(uap, who))) == NULL) break; LIST_FOREACH(p, &pg->pg_members, p_pglist) { - error = donice(curp, p, SCARG(uap, prio)); - found++; +#ifdef MAC + if (!mac_cred_check_visible(curp->p_ucred, + p->p_ucred)) { +#endif + error = donice(curp, p, SCARG(uap, prio)); + found++; +#ifdef MAC + } +#endif } break; } @@ -157,11 +181,20 @@ sys_setpriority(struct proc *curp, void *v, register_t *retval) case PRIO_USER: if (SCARG(uap, who) == 0) SCARG(uap, who) = curp->p_ucred->cr_uid; - LIST_FOREACH(p, &allproc, p_list) + LIST_FOREACH(p, &allproc, p_list) { if (p->p_ucred->cr_uid == SCARG(uap, who)) { - error = donice(curp, p, SCARG(uap, prio)); - found++; +#ifdef MAC + if (!mac_cred_check_visible(curp->p_ucred, + p->p_ucred)) { +#endif + error = donice(curp, p, SCARG(uap, + prio)); + found++; +#ifdef MAC + } +#endif } + } break; default: @@ -177,6 +210,9 @@ donice(struct proc *curp, struct proc *chgp, int n) { struct pcred *pcred = curp->p_cred; int s; +#ifdef MAC + int error; +#endif if (pcred->pc_ucred->cr_uid && pcred->p_ruid && pcred->pc_ucred->cr_uid != chgp->p_ucred->cr_uid && @@ -189,6 +225,11 @@ donice(struct proc *curp, struct proc *chgp, int n) n += NZERO; if (n < chgp->p_nice && suser(curp, 0)) return (EACCES); +#ifdef MAC + error = mac_proc_check_sched(curp->p_ucred, chgp); + if (error) + return (error); +#endif chgp->p_nice = n; SCHED_LOCK(s); (void)resetpriority(chgp); diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c index 562e3a4..f21f960 100644 --- a/sys/kern/kern_sig.c +++ b/sys/kern/kern_sig.c @@ -71,6 +71,10 @@ #include #include /* for coredump */ +#ifdef MAC +#include +#endif + int filt_sigattach(struct knote *kn); void filt_sigdetach(struct knote *kn); int filt_signal(struct knote *kn, long hint); @@ -108,6 +112,11 @@ cansignal(struct proc *p, struct pcred *pc, struct proc *q, int signum) if (signum == SIGCONT && q->p_session == p->p_session) return (1); /* SIGCONT in session */ +#ifdef MAC + if (mac_proc_check_signal(pc->pc_ucred, q, signum)) + return (0); +#endif + /* * Using kill(), only certain signals can be sent to setugid * child processes diff --git a/sys/kern/kern_sysctl.c b/sys/kern/kern_sysctl.c index 152e9d9..77bab9a 100644 --- a/sys/kern/kern_sysctl.c +++ b/sys/kern/kern_sysctl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: deraadt $ */ +/* $OpenBSD: kern_sysctl.c,v 1.157 2007/09/07 15:00:20 art Exp $ */ /* $NetBSD: kern_sysctl.c,v 1.17 1996/05/20 17:49:05 mrg Exp $ */ /*- @@ -101,6 +101,10 @@ #include #endif +#ifdef MAC +#include +#endif + #define PTRTOINT64(_x) ((u_int64_t)(u_long)(_x)) extern struct forkstat forkstat; @@ -193,6 +197,11 @@ sys___sysctl(struct proc *p, void *v, register_t *retval) fn = ddb_sysctl; break; #endif +#ifdef MAC + case CTL_SECURITY: + fn = security_sysctl; + break; +#endif default: return (EOPNOTSUPP); } @@ -217,8 +226,14 @@ sys___sysctl(struct proc *p, void *v, register_t *retval) } savelen = oldlen; } - error = (*fn)(&name[1], SCARG(uap, namelen) - 1, SCARG(uap, old), - &oldlen, SCARG(uap, new), SCARG(uap, newlen), p); + +#ifdef MAC + error = mac_system_check_sysctl(p->p_ucred, name, uap, oldlen); + if (!error) +#endif + error = (*fn)(&name[1], SCARG(uap, namelen) - 1, + SCARG(uap, old), &oldlen, SCARG(uap, new), + SCARG(uap, newlen), p); if (SCARG(uap, old) != NULL) { if (dolock) uvm_vsunlock(p, SCARG(uap, old), savelen); @@ -984,6 +999,11 @@ sysctl_file(char *where, size_t *sizep, struct proc *p) where += sizeof(filehead); /* + * XXX PM: This function needs to be rewritten so we can filter files + * opened by non-accessible processes using mac_cred_check_visible(). + */ + + /* * followed by an array of file structures */ LIST_FOREACH(fp, &filehead, f_list) { @@ -1334,6 +1354,13 @@ again: */ if (p->p_stat == SIDL) continue; +#ifdef MAC + /* + * Show a user only appropriate processes. + */ + if (mac_cred_check_visible(curproc->p_ucred, p->p_ucred)) + continue; +#endif /* * TODO - make more efficient (see notes below). */ @@ -1703,6 +1730,12 @@ sysctl_proc_args(int *name, u_int namelen, void *oldp, size_t *oldlenp, if ((vp = pfind(pid)) == NULL) return (ESRCH); +#ifdef MAC + error = mac_cred_check_visible(cp->p_ucred, vp->p_ucred); + if (error) + return (error); +#endif + if (oldp == NULL) { if (op == KERN_PROC_NARGV || op == KERN_PROC_NENV) *oldlenp = sizeof(int); @@ -2053,13 +2086,13 @@ sysctl_sysvipc(int *name, u_int namelen, void *where, size_t *sizep) switch (*name) { #ifdef SYSVMSG case KERN_SYSVIPC_MSG_INFO: - bcopy(&msqids[i], &msgsi->msgids[i], dssize); + bcopy(&msqids[i].u, &msgsi->msgids[i], dssize); break; #endif #ifdef SYSVSEM case KERN_SYSVIPC_SEM_INFO: if (sema[i] != NULL) - bcopy(sema[i], &semsi->semids[i], + bcopy(&sema[i]->u, &semsi->semids[i], dssize); else bzero(&semsi->semids[i], dssize); @@ -2068,7 +2101,7 @@ sysctl_sysvipc(int *name, u_int namelen, void *where, size_t *sizep) #ifdef SYSVSHM case KERN_SYSVIPC_SHM_INFO: if (shmsegs[i] != NULL) - bcopy(shmsegs[i], &shmsi->shmids[i], + bcopy(&shmsegs[i]->u, &shmsi->shmids[i], dssize); else bzero(&shmsi->shmids[i], dssize); diff --git a/sys/kern/kern_xxx.c b/sys/kern/kern_xxx.c index 4a79488..fa48ea7 100644 --- a/sys/kern/kern_xxx.c +++ b/sys/kern/kern_xxx.c @@ -42,6 +42,10 @@ #include #include +#ifdef MAC +#include +#endif + /* ARGSUSED */ int sys_reboot(struct proc *p, void *v, register_t *retval) @@ -66,6 +70,11 @@ sys_reboot(struct proc *p, void *v, register_t *retval) } } +#ifdef MAC + error = mac_system_check_reboot(p->p_ucred, SCARG(uap, opt)); + if (error) + return (error); +#endif boot(SCARG(uap, opt)); atomic_clearbits_int(&p->p_flag, P_CPUPEG); /* XXX */ diff --git a/sys/kern/subr_pool.c b/sys/kern/subr_pool.c index 6e937d5..78429f6 100644 --- a/sys/kern/subr_pool.c +++ b/sys/kern/subr_pool.c @@ -436,7 +436,11 @@ pool_alloc_item_header(struct pool *pp, caddr_t storage, int flags) if ((pp->pr_roflags & PR_PHINPAGE) != 0) ph = (struct pool_item_header *)(storage + pp->pr_phoffset); else { - ph = pool_get(&phpool, flags); + /* + * pool_alloc_item_header must not sleep because we also + * hold the lock of the initial pool. + */ + ph = pool_get(&phpool, flags & ~PR_WAITOK); } return (ph); diff --git a/sys/kern/subr_posix1e.c b/sys/kern/subr_posix1e.c new file mode 100644 index 0000000..c8ddf7c --- /dev/null +++ b/sys/kern/subr_posix1e.c @@ -0,0 +1,625 @@ +/* + * Copyright (c) 1999-2006 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: subr_acl_posix1e.c,v 1.54 2008/10/28 21:58:48 trasz Exp $ + */ + +/* + * Developed by the TrustedBSD Project. + * + * ACL support routines specific to POSIX.1e access control lists. These are + * utility routines for code common across file systems implementing POSIX.1e + * ACLs. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Implement a version of vaccess() that understands POSIX.1e ACL semantics; + * the access ACL has already been prepared for evaluation by the file system + * and is passed via 'uid', 'gid', and 'acl'. Return 0 on success, else an + * errno value. + */ +int +vaccess_acl_posix1e(enum vtype type, uid_t file_uid, gid_t file_gid, + struct acl *acl, accmode_t accmode, struct ucred *cred) +{ + struct acl_entry *acl_other, *acl_mask; + accmode_t dac_granted; + accmode_t priv_granted; + accmode_t acl_mask_granted; + int group_matched, i; + + /* + * Look for a normal, non-privileged way to access the file/directory + * as requested. If it exists, go with that. Otherwise, attempt to + * use privileges granted via priv_granted. In some cases, which + * privileges to use may be ambiguous due to "best match", in which + * case fall back on first match for the time being. + */ + + /* + * Determine privileges now, but don't apply until we've found a DAC + * entry that matches but has failed to allow access. + * + * XXXRW: Ideally, we'd determine the privileges required before + * asking for them. + */ + priv_granted = 0; + + if (type == VDIR) { + if ((accmode & VEXEC) && !priv_check_cred(cred, + PRIV_VFS_LOOKUP, 0)) + priv_granted |= VEXEC; + } else { + if ((accmode & VEXEC) && !priv_check_cred(cred, + PRIV_VFS_EXEC, 0)) + priv_granted |= VEXEC; + } + + if ((accmode & VREAD) && !priv_check_cred(cred, PRIV_VFS_READ, 0)) + priv_granted |= VREAD; + + if (((accmode & VWRITE) || (accmode & VAPPEND)) && + !priv_check_cred(cred, PRIV_VFS_WRITE, 0)) + priv_granted |= (VWRITE | VAPPEND); + + if ((accmode & VADMIN) && !priv_check_cred(cred, PRIV_VFS_ADMIN, 0)) + priv_granted |= VADMIN; + + /* + * The owner matches if the effective uid associated with the + * credential matches that of the ACL_USER_OBJ entry. While we're + * doing the first scan, also cache the location of the ACL_MASK and + * ACL_OTHER entries, preventing some future iterations. + */ + acl_mask = acl_other = NULL; + for (i = 0; i < acl->acl_cnt; i++) { + switch (acl->acl_entry[i].ae_tag) { + case ACL_USER_OBJ: + if (file_uid != cred->cr_uid) + break; + dac_granted = 0; + dac_granted |= VADMIN; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + if ((accmode & dac_granted) == accmode) + return (0); + + /* + * XXXRW: Do privilege lookup here. + */ + if ((accmode & (dac_granted | priv_granted)) == + accmode) { + return (0); + } + goto error; + + case ACL_MASK: + acl_mask = &acl->acl_entry[i]; + break; + + case ACL_OTHER: + acl_other = &acl->acl_entry[i]; + break; + + default: + break; + } + } + + /* + * An ACL_OTHER entry should always exist in a valid access ACL. If + * it doesn't, then generate a serious failure. For now, this means + * a debugging message and EPERM, but in the future should probably + * be a panic. + */ + if (acl_other == NULL) { + /* + * XXX This should never happen + */ + printf("vaccess_acl_posix1e: ACL_OTHER missing\n"); + return (EPERM); + } + + /* + * Checks against ACL_USER, ACL_GROUP_OBJ, and ACL_GROUP fields are + * masked by an ACL_MASK entry, if any. As such, first identify the + * ACL_MASK field, then iterate through identifying potential user + * matches, then group matches. If there is no ACL_MASK, assume that + * the mask allows all requests to succeed. + */ + if (acl_mask != NULL) { + acl_mask_granted = 0; + if (acl_mask->ae_perm & ACL_EXECUTE) + acl_mask_granted |= VEXEC; + if (acl_mask->ae_perm & ACL_READ) + acl_mask_granted |= VREAD; + if (acl_mask->ae_perm & ACL_WRITE) + acl_mask_granted |= (VWRITE | VAPPEND); + } else + acl_mask_granted = VEXEC | VREAD | VWRITE | VAPPEND; + + /* + * Check ACL_USER ACL entries. There will either be one or no + * matches; if there is one, we accept or rejected based on the + * match; otherwise, we continue on to groups. + */ + for (i = 0; i < acl->acl_cnt; i++) { + switch (acl->acl_entry[i].ae_tag) { + case ACL_USER: + if (acl->acl_entry[i].ae_id != cred->cr_uid) + break; + dac_granted = 0; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + dac_granted &= acl_mask_granted; + if ((accmode & dac_granted) == accmode) + return (0); + /* + * XXXRW: Do privilege lookup here. + */ + if ((accmode & (dac_granted | priv_granted)) != + accmode) + goto error; + + return (0); + } + } + + /* + * Group match is best-match, not first-match, so find a "best" + * match. Iterate across, testing each potential group match. Make + * sure we keep track of whether we found a match or not, so that we + * know if we should try again with any available privilege, or if we + * should move on to ACL_OTHER. + */ + group_matched = 0; + for (i = 0; i < acl->acl_cnt; i++) { + switch (acl->acl_entry[i].ae_tag) { + case ACL_GROUP_OBJ: + if (!groupmember(file_gid, cred)) + break; + dac_granted = 0; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + dac_granted &= acl_mask_granted; + + if ((accmode & dac_granted) == accmode) + return (0); + + group_matched = 1; + break; + + case ACL_GROUP: + if (!groupmember(acl->acl_entry[i].ae_id, cred)) + break; + dac_granted = 0; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + dac_granted &= acl_mask_granted; + + if ((accmode & dac_granted) == accmode) + return (0); + + group_matched = 1; + break; + + default: + break; + } + } + + if (group_matched == 1) { + /* + * There was a match, but it did not grant rights via pure + * DAC. Try again, this time with privilege. + */ + for (i = 0; i < acl->acl_cnt; i++) { + switch (acl->acl_entry[i].ae_tag) { + case ACL_GROUP_OBJ: + if (!groupmember(file_gid, cred)) + break; + dac_granted = 0; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + dac_granted &= acl_mask_granted; + + /* + * XXXRW: Do privilege lookup here. + */ + if ((accmode & (dac_granted | priv_granted)) + != accmode) + break; + + return (0); + + case ACL_GROUP: + if (!groupmember(acl->acl_entry[i].ae_id, + cred)) + break; + dac_granted = 0; + if (acl->acl_entry[i].ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl->acl_entry[i].ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl->acl_entry[i].ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + dac_granted &= acl_mask_granted; + + /* + * XXXRW: Do privilege lookup here. + */ + if ((accmode & (dac_granted | priv_granted)) + != accmode) + break; + + return (0); + + default: + break; + } + } + /* + * Even with privilege, group membership was not sufficient. + * Return failure. + */ + goto error; + } + + /* + * Fall back on ACL_OTHER. ACL_MASK is not applied to ACL_OTHER. + */ + dac_granted = 0; + if (acl_other->ae_perm & ACL_EXECUTE) + dac_granted |= VEXEC; + if (acl_other->ae_perm & ACL_READ) + dac_granted |= VREAD; + if (acl_other->ae_perm & ACL_WRITE) + dac_granted |= (VWRITE | VAPPEND); + + if ((accmode & dac_granted) == accmode) + return (0); + /* + * XXXRW: Do privilege lookup here. + */ + if ((accmode & (dac_granted | priv_granted)) == accmode) { + return (0); + } + +error: + return ((accmode & VADMIN) ? EPERM : EACCES); +} + +/* + * For the purposes of filesystems maintaining the _OBJ entries in an inode + * with a mode_t field, this routine converts a mode_t entry to an + * acl_perm_t. + */ +acl_perm_t +acl_posix1e_mode_to_perm(acl_tag_t tag, mode_t mode) +{ + acl_perm_t perm = 0; + + switch(tag) { + case ACL_USER_OBJ: + if (mode & S_IXUSR) + perm |= ACL_EXECUTE; + if (mode & S_IRUSR) + perm |= ACL_READ; + if (mode & S_IWUSR) + perm |= ACL_WRITE; + return (perm); + + case ACL_GROUP_OBJ: + if (mode & S_IXGRP) + perm |= ACL_EXECUTE; + if (mode & S_IRGRP) + perm |= ACL_READ; + if (mode & S_IWGRP) + perm |= ACL_WRITE; + return (perm); + + case ACL_OTHER: + if (mode & S_IXOTH) + perm |= ACL_EXECUTE; + if (mode & S_IROTH) + perm |= ACL_READ; + if (mode & S_IWOTH) + perm |= ACL_WRITE; + return (perm); + + default: + printf("acl_posix1e_mode_to_perm: invalid tag (%d)\n", tag); + return (0); + } +} + +/* + * Given inode information (uid, gid, mode), return an acl entry of the + * appropriate type. + */ +struct acl_entry +acl_posix1e_mode_to_entry(acl_tag_t tag, uid_t uid, gid_t gid, mode_t mode) +{ + struct acl_entry acl_entry; + + acl_entry.ae_tag = tag; + acl_entry.ae_perm = acl_posix1e_mode_to_perm(tag, mode); + switch(tag) { + case ACL_USER_OBJ: + acl_entry.ae_id = uid; + break; + + case ACL_GROUP_OBJ: + acl_entry.ae_id = gid; + break; + + case ACL_OTHER: + acl_entry.ae_id = ACL_UNDEFINED_ID; + break; + + default: + acl_entry.ae_id = ACL_UNDEFINED_ID; + printf("acl_posix1e_mode_to_entry: invalid tag (%d)\n", tag); + } + + return (acl_entry); +} + +/* + * Utility function to generate a file mode given appropriate ACL entries. + */ +mode_t +acl_posix1e_perms_to_mode(struct acl_entry *acl_user_obj_entry, + struct acl_entry *acl_group_obj_entry, struct acl_entry *acl_other_entry) +{ + mode_t mode; + + mode = 0; + if (acl_user_obj_entry->ae_perm & ACL_EXECUTE) + mode |= S_IXUSR; + if (acl_user_obj_entry->ae_perm & ACL_READ) + mode |= S_IRUSR; + if (acl_user_obj_entry->ae_perm & ACL_WRITE) + mode |= S_IWUSR; + if (acl_group_obj_entry->ae_perm & ACL_EXECUTE) + mode |= S_IXGRP; + if (acl_group_obj_entry->ae_perm & ACL_READ) + mode |= S_IRGRP; + if (acl_group_obj_entry->ae_perm & ACL_WRITE) + mode |= S_IWGRP; + if (acl_other_entry->ae_perm & ACL_EXECUTE) + mode |= S_IXOTH; + if (acl_other_entry->ae_perm & ACL_READ) + mode |= S_IROTH; + if (acl_other_entry->ae_perm & ACL_WRITE) + mode |= S_IWOTH; + + return (mode); +} + +/* + * Utility function to generate a file mode given a complete POSIX.1e access + * ACL. Note that if the ACL is improperly formed, this may result in a + * panic. + */ +mode_t +acl_posix1e_acl_to_mode(struct acl *acl) +{ + struct acl_entry *acl_mask, *acl_user_obj, *acl_group_obj, *acl_other; + int i; + + /* + * Find the ACL entries relevant to a POSIX permission mode. + */ + acl_user_obj = acl_group_obj = acl_other = acl_mask = NULL; + for (i = 0; i < acl->acl_cnt; i++) { + switch (acl->acl_entry[i].ae_tag) { + case ACL_USER_OBJ: + acl_user_obj = &acl->acl_entry[i]; + break; + + case ACL_GROUP_OBJ: + acl_group_obj = &acl->acl_entry[i]; + break; + + case ACL_OTHER: + acl_other = &acl->acl_entry[i]; + break; + + case ACL_MASK: + acl_mask = &acl->acl_entry[i]; + break; + + case ACL_USER: + case ACL_GROUP: + break; + + default: + panic("acl_posix1e_acl_to_mode: bad ae_tag"); + } + } + + if (acl_user_obj == NULL || acl_group_obj == NULL || acl_other == NULL) + panic("acl_posix1e_acl_to_mode: missing base ae_tags"); + + /* + * POSIX.1e specifies that if there is an ACL_MASK entry, we replace + * the mode "group" bits with its permissions. If there isn't, we + * use the ACL_GROUP_OBJ permissions. + */ + if (acl_mask != NULL) + return (acl_posix1e_perms_to_mode(acl_user_obj, acl_mask, + acl_other)); + else + return (acl_posix1e_perms_to_mode(acl_user_obj, acl_group_obj, + acl_other)); +} + +/* + * Perform a syntactic check of the ACL, sufficient to allow an implementing + * filesystem to determine if it should accept this and rely on the POSIX.1e + * ACL properties. + */ +int +acl_posix1e_check(struct acl *acl) +{ + int num_acl_user_obj, num_acl_user, num_acl_group_obj, num_acl_group; + int num_acl_mask, num_acl_other, i; + + /* + * Verify that the number of entries does not exceed the maximum + * defined for acl_t. + * + * Verify that the correct number of various sorts of ae_tags are + * present: + * Exactly one ACL_USER_OBJ + * Exactly one ACL_GROUP_OBJ + * Exactly one ACL_OTHER + * If any ACL_USER or ACL_GROUP entries appear, then exactly one + * ACL_MASK entry must also appear. + * + * Verify that all ae_perm entries are in ACL_PERM_BITS. + * + * Verify all ae_tag entries are understood by this implementation. + * + * Note: Does not check for uniqueness of qualifier (ae_id) field. + */ + num_acl_user_obj = num_acl_user = num_acl_group_obj = num_acl_group = + num_acl_mask = num_acl_other = 0; + if (acl->acl_cnt > ACL_MAX_ENTRIES || acl->acl_cnt < 0) + return (EINVAL); + for (i = 0; i < acl->acl_cnt; i++) { + /* + * Check for a valid tag. + */ + switch(acl->acl_entry[i].ae_tag) { + case ACL_USER_OBJ: + acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID; /* XXX */ + if (acl->acl_entry[i].ae_id != ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_user_obj++; + break; + case ACL_GROUP_OBJ: + acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID; /* XXX */ + if (acl->acl_entry[i].ae_id != ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_group_obj++; + break; + case ACL_USER: + if (acl->acl_entry[i].ae_id == ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_user++; + break; + case ACL_GROUP: + if (acl->acl_entry[i].ae_id == ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_group++; + break; + case ACL_OTHER: + acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID; /* XXX */ + if (acl->acl_entry[i].ae_id != ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_other++; + break; + case ACL_MASK: + acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID; /* XXX */ + if (acl->acl_entry[i].ae_id != ACL_UNDEFINED_ID) + return (EINVAL); + num_acl_mask++; + break; + default: + return (EINVAL); + } + /* + * Check for valid perm entries. + */ + if ((acl->acl_entry[i].ae_perm | ACL_PERM_BITS) != + ACL_PERM_BITS) + return (EINVAL); + } + if ((num_acl_user_obj != 1) || (num_acl_group_obj != 1) || + (num_acl_other != 1) || (num_acl_mask != 0 && num_acl_mask != 1)) + return (EINVAL); + if (((num_acl_group != 0) || (num_acl_user != 0)) && + (num_acl_mask != 1)) + return (EINVAL); + return (0); +} + +/* + * Given a requested mode for a new object, and a default ACL, combine the + * two to produce a new mode. Be careful not to clear any bits that aren't + * intended to be affected by the POSIX.1e ACL. Eventually, this might also + * take the cmask as an argument, if we push that down into + * per-filesystem-code. + */ +mode_t +acl_posix1e_newfilemode(mode_t cmode, struct acl *dacl) +{ + mode_t mode; + + mode = cmode; + /* + * The current composition policy is that a permission bit must be + * set in *both* the ACL and the requested creation mode for it to + * appear in the resulting mode/ACL. First clear any possibly + * effected bits, then reconstruct. + */ + mode &= ACL_PRESERVE_MASK; + mode |= (ACL_OVERRIDE_MASK & cmode & acl_posix1e_acl_to_mode(dacl)); + + return (mode); +} diff --git a/sys/kern/subr_sbuf.c b/sys/kern/subr_sbuf.c new file mode 100644 index 0000000..c2dae75 --- /dev/null +++ b/sys/kern/subr_sbuf.c @@ -0,0 +1,566 @@ +/* + * Copyright (c) 2000 Poul-Henning Kamp and Dag-Erling Coïdan Smørgrav + * 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 + * in this position and unchanged. + * 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. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. + * + * $FreeBSD: subr_sbuf.c,v 1.30 2005/12/23 11:49:53 phk Exp $ + */ + +#include + +#ifdef _KERNEL +#include +#include +#include +#include +#include +#else /* _KERNEL */ +#include +#include +#include +#include +#include +#endif /* _KERNEL */ + +#include + +#ifdef _KERNEL +#define SBMALLOC(size) malloc(size, M_SBUF, M_WAITOK) +#define SBFREE(buf) free(buf, M_SBUF) +#else /* _KERNEL */ +#define KASSERT(e) +#define SBMALLOC(size) malloc(size) +#define SBFREE(buf) free(buf) +#define min(x,y) MIN(x,y) +#endif /* _KERNEL */ + +/* + * Predicates + */ +#define SBUF_ISDYNAMIC(s) ((s)->s_flags & SBUF_DYNAMIC) +#define SBUF_ISDYNSTRUCT(s) ((s)->s_flags & SBUF_DYNSTRUCT) +#define SBUF_ISFINISHED(s) ((s)->s_flags & SBUF_FINISHED) +#define SBUF_HASOVERFLOWED(s) ((s)->s_flags & SBUF_OVERFLOWED) +#define SBUF_HASROOM(s) ((s)->s_len < (s)->s_size - 1) +#define SBUF_FREESPACE(s) ((s)->s_size - (s)->s_len - 1) +#define SBUF_CANEXTEND(s) ((s)->s_flags & SBUF_AUTOEXTEND) + +/* + * Set / clear flags + */ +#define SBUF_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) +#define SBUF_CLEARFLAG(s, f) do { (s)->s_flags &= ~(f); } while (0) + +#define SBUF_MINEXTENDSIZE 16 /* Should be power of 2. */ +#define SBUF_MAXEXTENDSIZE PAGE_SIZE +#define SBUF_MAXEXTENDINCR PAGE_SIZE + +/* + * Local functions + */ +int sbuf_extendsize(int); +int sbuf_extend(struct sbuf *, int); + +/* + * Debugging support + */ +#if defined(_KERNEL) && defined(DEBUG) +void +_assert_sbuf_integrity(const char *fun, struct sbuf *s) +{ + KASSERT(s != NULL); + KASSERT(s->s_buf != NULL); + KASSERT(s->s_len < s->s_size); +} + +void +_assert_sbuf_state(const char *fun, struct sbuf *s, int state) +{ + KASSERT((s->s_flags & SBUF_FINISHED) == state); +} +#define assert_sbuf_integrity(s) _assert_sbuf_integrity(__func__, (s)) +#define assert_sbuf_state(s, i) _assert_sbuf_state(__func__, (s), (i)) +#else /* _KERNEL && DEBUG */ +#define assert_sbuf_integrity(s) do { } while (0) +#define assert_sbuf_state(s, i) do { } while (0) +#endif /* _KERNEL && DEBUG */ + +int +sbuf_extendsize(int size) +{ + int newsize; + + newsize = SBUF_MINEXTENDSIZE; + while (newsize < size) { + if (newsize < (int)SBUF_MAXEXTENDSIZE) + newsize *= 2; + else + newsize += SBUF_MAXEXTENDINCR; + } + + return (newsize); +} + + +/* + * Extend an sbuf. + */ +int +sbuf_extend(struct sbuf *s, int addlen) +{ + char *newbuf; + int newsize; + + if (!SBUF_CANEXTEND(s)) + return (-1); + + newsize = sbuf_extendsize(s->s_size + addlen); + newbuf = (char *)SBMALLOC(newsize); + if (newbuf == NULL) + return (-1); + bcopy(s->s_buf, newbuf, s->s_size); + if (SBUF_ISDYNAMIC(s)) + SBFREE(s->s_buf); + else + SBUF_SETFLAG(s, SBUF_DYNAMIC); + s->s_buf = newbuf; + s->s_size = newsize; + return (0); +} + +/* + * Initialize an sbuf. + * If buf is non-NULL, it points to a static or already-allocated string + * big enough to hold at least length characters. + */ +struct sbuf * +sbuf_new(struct sbuf *s, char *buf, int length, int flags) +{ + KASSERT(length >= 0); + KASSERT((flags & ~SBUF_USRFLAGMSK) == 0); + + flags &= SBUF_USRFLAGMSK; + if (s == NULL) { + s = (struct sbuf *)SBMALLOC(sizeof *s); + if (s == NULL) + return (NULL); + bzero(s, sizeof *s); + s->s_flags = flags; + SBUF_SETFLAG(s, SBUF_DYNSTRUCT); + } else { + bzero(s, sizeof *s); + s->s_flags = flags; + } + s->s_size = length; + if (buf) { + s->s_buf = buf; + return (s); + } + if (flags & SBUF_AUTOEXTEND) + s->s_size = sbuf_extendsize(s->s_size); + s->s_buf = (char *)SBMALLOC(s->s_size); + if (s->s_buf == NULL) { + if (SBUF_ISDYNSTRUCT(s)) + SBFREE(s); + return (NULL); + } + SBUF_SETFLAG(s, SBUF_DYNAMIC); + return (s); +} + +#ifdef _KERNEL +/* + * Create an sbuf with uio data + */ +struct sbuf * +sbuf_uionew(struct sbuf *s, struct uio *uio, int *error) +{ + KASSERT(uio != NULL); + KASSERT(error != NULL); + + s = sbuf_new(s, NULL, uio->uio_resid + 1, 0); + if (s == NULL) { + *error = ENOMEM; + return (NULL); + } + *error = uiomove(s->s_buf, uio->uio_resid, uio); + if (*error != 0) { + sbuf_delete(s); + return (NULL); + } + s->s_len = s->s_size - 1; + *error = 0; + return (s); +} +#endif + +/* + * Clear an sbuf and reset its position. + */ +void +sbuf_clear(struct sbuf *s) +{ + assert_sbuf_integrity(s); + /* don't care if it's finished or not */ + + SBUF_CLEARFLAG(s, SBUF_FINISHED); + SBUF_CLEARFLAG(s, SBUF_OVERFLOWED); + s->s_len = 0; +} + +/* + * Set the sbuf's end position to an arbitrary value. + * Effectively truncates the sbuf at the new position. + */ +int +sbuf_setpos(struct sbuf *s, int pos) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + KASSERT(pos >= 0); + KASSERT(pos < s->s_size); + + if (pos < 0 || pos > s->s_len) + return (-1); + s->s_len = pos; + return (0); +} + +/* + * Append a byte string to an sbuf. + */ +int +sbuf_bcat(struct sbuf *s, const void *buf, size_t len) +{ + const char *str = buf; + + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + for (; len; len--) { + if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0) + break; + s->s_buf[s->s_len++] = *str++; + } + if (len) { + SBUF_SETFLAG(s, SBUF_OVERFLOWED); + return (-1); + } + return (0); +} + +#ifdef _KERNEL +/* + * Copy a byte string from userland into an sbuf. + */ +int +sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + if (len == 0) + return (0); + if (len > SBUF_FREESPACE(s)) { + sbuf_extend(s, len - SBUF_FREESPACE(s)); + len = min(len, SBUF_FREESPACE(s)); + } + if (copyin(uaddr, s->s_buf + s->s_len, len) != 0) + return (-1); + s->s_len += len; + + return (0); +} +#endif + +/* + * Copy a byte string into an sbuf. + */ +int +sbuf_bcpy(struct sbuf *s, const void *buf, size_t len) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + sbuf_clear(s); + return (sbuf_bcat(s, buf, len)); +} + +/* + * Append a string to an sbuf. + */ +int +sbuf_cat(struct sbuf *s, const char *str) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + while (*str) { + if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0) + break; + s->s_buf[s->s_len++] = *str++; + } + if (*str) { + SBUF_SETFLAG(s, SBUF_OVERFLOWED); + return (-1); + } + return (0); +} + +#ifdef _KERNEL +/* + * Append a string from userland to an sbuf. + */ +int +sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len) +{ + size_t done; + + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + if (len == 0) + len = SBUF_FREESPACE(s); /* XXX return 0? */ + if (len > SBUF_FREESPACE(s)) { + sbuf_extend(s, len); + len = min(len, SBUF_FREESPACE(s)); + } + switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) { + case ENAMETOOLONG: + SBUF_SETFLAG(s, SBUF_OVERFLOWED); + /* fall through */ + case 0: + s->s_len += done - 1; + break; + default: + return (-1); /* XXX */ + } + + return (done); +} +#endif + +/* + * Copy a string into an sbuf. + */ +int +sbuf_cpy(struct sbuf *s, const char *str) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + sbuf_clear(s); + return (sbuf_cat(s, str)); +} + +/* + * Format the given argument list and append the resulting string to an sbuf. + */ +int +sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap) +{ + va_list ap_copy; + int len; + + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + KASSERT(fmt != NULL); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + do { + va_copy(ap_copy, ap); + len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1, + fmt, ap_copy); + va_end(ap_copy); + } while (len > SBUF_FREESPACE(s) && + sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0); + + /* + * s->s_len is the length of the string, without the terminating nul. + * When updating s->s_len, we must subtract 1 from the length that + * we passed into vsnprintf() because that length includes the + * terminating nul. + * + * vsnprintf() returns the amount that would have been copied, + * given sufficient space, hence the min() calculation below. + */ + s->s_len += min(len, SBUF_FREESPACE(s)); + if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s)) + SBUF_SETFLAG(s, SBUF_OVERFLOWED); + + KASSERT(s->s_len < s->s_size); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + return (0); +} + +/* + * Format the given arguments and append the resulting string to an sbuf. + */ +int +sbuf_printf(struct sbuf *s, const char *fmt, ...) +{ + va_list ap; + int result; + + va_start(ap, fmt); + result = sbuf_vprintf(s, fmt, ap); + va_end(ap); + return(result); +} + +/* + * Append a character to an sbuf. + */ +int +sbuf_putc(struct sbuf *s, int c) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) { + SBUF_SETFLAG(s, SBUF_OVERFLOWED); + return (-1); + } + if (c != '\0') + s->s_buf[s->s_len++] = c; + return (0); +} + +/* + * Trim whitespace characters from end of an sbuf. + */ +int +sbuf_trim(struct sbuf *s) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + + while (s->s_len && isspace(s->s_buf[s->s_len-1])) + --s->s_len; + + return (0); +} + +/* + * Check if an sbuf overflowed + */ +int +sbuf_overflowed(struct sbuf *s) +{ + return (SBUF_HASOVERFLOWED(s)); +} + +/* + * Finish off an sbuf. + */ +void +sbuf_finish(struct sbuf *s) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, 0); + + s->s_buf[s->s_len] = '\0'; + SBUF_CLEARFLAG(s, SBUF_OVERFLOWED); + SBUF_SETFLAG(s, SBUF_FINISHED); +} + +/* + * Return a pointer to the sbuf data. + */ +char * +sbuf_data(struct sbuf *s) +{ + assert_sbuf_integrity(s); + assert_sbuf_state(s, SBUF_FINISHED); + + return (s->s_buf); +} + +/* + * Return the length of the sbuf data. + */ +int +sbuf_len(struct sbuf *s) +{ + assert_sbuf_integrity(s); + /* don't care if it's finished or not */ + + if (SBUF_HASOVERFLOWED(s)) + return (-1); + return (s->s_len); +} + +/* + * Clear an sbuf, free its buffer if necessary. + */ +void +sbuf_delete(struct sbuf *s) +{ + int isdyn; + + assert_sbuf_integrity(s); + /* don't care if it's finished or not */ + + if (SBUF_ISDYNAMIC(s)) + SBFREE(s->s_buf); + isdyn = SBUF_ISDYNSTRUCT(s); + bzero(s, sizeof *s); + if (isdyn) + SBFREE(s); +} + +/* + * Check if an sbuf has been finished. + */ +int +sbuf_done(struct sbuf *s) +{ + + return (SBUF_ISFINISHED(s)); +} diff --git a/sys/kern/sys_pipe.c b/sys/kern/sys_pipe.c index b4f2b60..0dbd531 100644 --- a/sys/kern/sys_pipe.c +++ b/sys/kern/sys_pipe.c @@ -45,6 +45,10 @@ #include +#ifdef MAC +#include +#endif + /* * interfaces to the outside world */ @@ -105,23 +109,53 @@ sys_opipe(struct proc *p, void *v, register_t *retval) { struct filedesc *fdp = p->p_fd; struct file *rf, *wf; + struct pipepair *pp; struct pipe *rpipe, *wpipe; int fd, error; fdplock(fdp); - rpipe = pool_get(&pipe_pool, PR_WAITOK); + /* Allocate the container and link the endpoints. */ + pp = pool_get(&pipe_pool, PR_WAITOK); + rpipe = &pp->pp_rpipe; + wpipe = &pp->pp_wpipe; + rpipe->pipe_pair = pp; + wpipe->pipe_pair = pp; + +#ifdef MAC + /* + * The MAC label is shared between the connected endpoints. As a + * result mac_pipe_init() and mac_pipe_create() are called once + * for the pair, and not on the endpoints. + */ + mac_pipe_init(pp); + mac_pipe_create(p->p_ucred, pp); +#endif + error = pipe_create(rpipe); - if (error != 0) - goto free1; - wpipe = pool_get(&pipe_pool, PR_WAITOK); + if (error != 0) { + pool_put(&pipe_pool, pp); + fdpunlock(fdp); + return (error); + } + error = pipe_create(wpipe); - if (error != 0) - goto free2; + if (error != 0) { + pipeclose(rpipe); + pool_put(&pipe_pool, pp); + fdpunlock(fdp); + return (error); + } error = falloc(p, &rf, &fd); - if (error != 0) - goto free2; + if (error != 0) { + pipeclose(rpipe); + pipeclose(wpipe); + pool_put(&pipe_pool, pp); + fdpunlock(fdp); + return (error); + } + rf->f_flag = FREAD | FWRITE; rf->f_type = DTYPE_PIPE; rf->f_data = rpipe; @@ -129,8 +163,16 @@ sys_opipe(struct proc *p, void *v, register_t *retval) retval[0] = fd; error = falloc(p, &wf, &fd); - if (error != 0) - goto free3; + if (error != 0) { + fdremove(fdp, retval[0]); + closef(rf, p); + pipeclose(rpipe); + pipeclose(wpipe); + pool_put(&pipe_pool, pp); + fdpunlock(fdp); + return (error); + } + wf->f_flag = FREAD | FWRITE; wf->f_type = DTYPE_PIPE; wf->f_data = wpipe; @@ -145,18 +187,6 @@ sys_opipe(struct proc *p, void *v, register_t *retval) fdpunlock(fdp); return (0); - -free3: - fdremove(fdp, retval[0]); - closef(rf, p); - rpipe = NULL; -free2: - (void)pipeclose(wpipe); -free1: - if (rpipe != NULL) - (void)pipeclose(rpipe); - fdpunlock(fdp); - return (error); } /* @@ -276,6 +306,15 @@ pipe_read(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) ++rpipe->pipe_busy; +#ifdef MAC + error = mac_pipe_check_read(cred, rpipe->pipe_pair); + if (error) { + --rpipe->pipe_busy; + pipeunlock(rpipe); + return (error); + } +#endif + while (uio->uio_resid) { /* * normal pipe buffer receive @@ -396,6 +435,14 @@ pipe_write(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) if ((wpipe == NULL) || (wpipe->pipe_state & PIPE_EOF)) { return (EPIPE); } + +#ifdef MAC + /* XXX PM: Pipe is not locked! */ + error = mac_pipe_check_write(cred, wpipe->pipe_pair); + if (error) + return (error); +#endif + ++wpipe->pipe_busy; /* @@ -607,6 +654,14 @@ pipe_ioctl(struct file *fp, u_long cmd, caddr_t data, struct proc *p) { struct pipe *mpipe = (struct pipe *)fp->f_data; +#ifdef MAC + int error; + /* XXX PM: Pipe is not locked! */ + error = mac_pipe_check_ioctl(p->p_ucred, mpipe->pipe_pair, cmd, data); + if (error) + return (error); +#endif + switch (cmd) { case FIONBIO: @@ -642,8 +697,19 @@ pipe_poll(struct file *fp, int events, struct proc *p) struct pipe *rpipe = (struct pipe *)fp->f_data; struct pipe *wpipe; int revents = 0; +#ifdef MAC + int error; +#endif wpipe = rpipe->pipe_peer; + +#ifdef MAC + /* XXX PM: Pipe is not locked! */ + error = mac_pipe_check_poll(p->p_ucred, rpipe->pipe_pair); + if (error) + return (0); +#endif + if (events & (POLLIN | POLLRDNORM)) { if ((rpipe->pipe_buffer.cnt > 0) || (rpipe->pipe_state & PIPE_EOF)) @@ -677,7 +743,13 @@ int pipe_stat(struct file *fp, struct stat *ub, struct proc *p) { struct pipe *pipe = (struct pipe *)fp->f_data; - +#ifdef MAC + int error; + /* XXX PM: Pipe is not locked! */ + error = mac_pipe_check_stat(p->p_ucred, pipe->pipe_pair); + if (error) + return (error); +#endif bzero(ub, sizeof(*ub)); ub->st_mode = S_IFIFO; ub->st_blksize = pipe->pipe_buffer.size; @@ -754,11 +826,22 @@ pipeclose(struct pipe *cpipe) ppipe->pipe_peer = NULL; } + pipe_free_kmem(cpipe); + cpipe->pipe_state |= PIPE_CLOSED; + /* - * free resources + * If both endpoints are now closed, release the memory + * for the pipe pair. */ - pipe_free_kmem(cpipe); - pool_put(&pipe_pool, cpipe); + if (ppipe != NULL && ppipe->pipe_state & PIPE_CLOSED) { +#ifdef DIAGNOSTIC + KASSERT(ppipe->pipe_pair == cpipe->pipe_pair); +#endif +#ifdef MAC + mac_pipe_destroy(ppipe->pipe_pair); +#endif + pool_put(&pipe_pool, ppipe->pipe_pair); + } } } @@ -842,7 +925,7 @@ filt_pipewrite(struct knote *kn, long hint) void pipe_init(void) { - pool_init(&pipe_pool, sizeof(struct pipe), 0, 0, 0, "pipepl", + pool_init(&pipe_pool, sizeof(struct pipepair), 0, 0, 0, "pipepl", &pool_allocator_nointr); } diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c index 4cbe449..8a05f10 100644 --- a/sys/kern/sys_process.c +++ b/sys/kern/sys_process.c @@ -70,6 +70,10 @@ int process_auxv_offset(struct proc *, struct proc *, struct uio *); +#ifdef MAC +#include +#endif + #ifdef PTRACE /* * Process debugging system call. @@ -111,6 +115,11 @@ sys_ptrace(struct proc *p, void *v, register_t *retval) /* Find the process we're supposed to be operating on. */ if ((t = pfind(SCARG(uap, pid))) == NULL) return (ESRCH); +#ifdef MAC + error = mac_proc_check_debug(p->p_ucred, t); + if (error) + return (error); +#endif } if ((t->p_flag & P_INEXEC) != 0) @@ -224,6 +233,12 @@ sys_ptrace(struct proc *p, void *v, register_t *retval) return (EINVAL); } +#ifdef MAC + error = mac_proc_check_debug(p->p_ucred, t); + if (error) + return (error); +#endif + /* Do single-step fixup if needed. */ FIX_SSTEP(t); diff --git a/sys/kern/sys_socket.c b/sys/kern/sys_socket.c index a99967f..b7c24ca 100644 --- a/sys/kern/sys_socket.c +++ b/sys/kern/sys_socket.c @@ -1,4 +1,4 @@ -/* $OpenBSD: otto $ */ +/* $OpenBSD: sys_socket.c,v 1.11 2007/02/26 23:53:33 kurt Exp $ */ /* $NetBSD: sys_socket.c,v 1.13 1995/08/12 23:59:09 mycroft Exp $ */ /* @@ -47,6 +47,10 @@ #include #include +#ifdef MAC +#include +#endif + struct fileops socketops = { soo_read, soo_write, soo_ioctl, soo_poll, soo_kqfilter, soo_stat, soo_close @@ -57,6 +61,13 @@ int soo_read(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) { +#ifdef MAC + int error; + + error = mac_socket_check_receive(cred, fp->f_data); + if (error) + return (error); +#endif return (soreceive((struct socket *)fp->f_data, (struct mbuf **)0, uio, (struct mbuf **)0, (struct mbuf **)0, (int *)0, (socklen_t)0)); @@ -67,6 +78,13 @@ int soo_write(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) { +#ifdef MAC + int error; + + error = mac_socket_check_send(cred, fp->f_data); + if (error) + return (error); +#endif return (sosend((struct socket *)fp->f_data, (struct mbuf *)0, uio, (struct mbuf *)0, (struct mbuf *)0, 0)); } @@ -132,9 +150,20 @@ int soo_poll(struct file *fp, int events, struct proc *p) { struct socket *so = (struct socket *)fp->f_data; +#ifdef MAC + int error; +#endif int revents = 0; int s = splsoftnet(); +#ifdef MAC + error = mac_socket_check_poll(p->p_ucred, so); + if (error) { + splx(s); + return (error); + } +#endif + if (events & (POLLIN | POLLRDNORM)) { if (soreadable(so)) revents |= events & (POLLIN | POLLRDNORM); @@ -165,6 +194,15 @@ int soo_stat(struct file *fp, struct stat *ub, struct proc *p) { struct socket *so = (struct socket *)fp->f_data; +#ifdef MAC + int error; +#endif + +#ifdef MAC + error = mac_socket_check_stat(p->p_ucred, so); + if (error) + return (error); +#endif bzero((caddr_t)ub, sizeof (*ub)); ub->st_mode = S_IFSOCK; diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c index c71e6a8..6a8b2ea 100644 --- a/sys/kern/syscalls.c +++ b/sys/kern/syscalls.c @@ -1,10 +1,10 @@ -/* $OpenBSD: deraadt $ */ +/* $OpenBSD$ */ /* * System call names. * * DO NOT EDIT-- this file is automatically generated. - * created from; OpenBSD: syscalls.master,v 1.93 2009/06/03 15:42:03 jj Exp + * created from; OpenBSD: jj */ char *syscallnames[] = { @@ -363,13 +363,13 @@ char *syscallnames[] = { "mlockall", /* 271 = mlockall */ "munlockall", /* 272 = munlockall */ "getpeereid", /* 273 = getpeereid */ - "#274 (unimplemented sys_extattrctl)", /* 274 = unimplemented sys_extattrctl */ - "#275 (unimplemented sys_extattr_set_file)", /* 275 = unimplemented sys_extattr_set_file */ - "#276 (unimplemented sys_extattr_get_file)", /* 276 = unimplemented sys_extattr_get_file */ - "#277 (unimplemented sys_extattr_delete_file)", /* 277 = unimplemented sys_extattr_delete_file */ - "#278 (unimplemented sys_extattr_set_fd)", /* 278 = unimplemented sys_extattr_set_fd */ - "#279 (unimplemented sys_extattr_get_fd)", /* 279 = unimplemented sys_extattr_get_fd */ - "#280 (unimplemented sys_extattr_delete_fd)", /* 280 = unimplemented sys_extattr_delete_fd */ + "#274 (unimplemented)", /* 274 = unimplemented */ + "#275 (unimplemented)", /* 275 = unimplemented */ + "#276 (unimplemented)", /* 276 = unimplemented */ + "#277 (unimplemented)", /* 277 = unimplemented */ + "#278 (unimplemented)", /* 278 = unimplemented */ + "#279 (unimplemented)", /* 279 = unimplemented */ + "#280 (unimplemented)", /* 280 = unimplemented */ "getresuid", /* 281 = getresuid */ "setresuid", /* 282 = setresuid */ "getresgid", /* 283 = getresgid */ @@ -427,4 +427,84 @@ char *syscallnames[] = { "statfs", /* 307 = statfs */ "fstatfs", /* 308 = fstatfs */ "fhstatfs", /* 309 = fhstatfs */ +#ifdef EXTATTR + "extattr_set_fd", /* 310 = extattr_set_fd */ + "extattr_get_fd", /* 311 = extattr_get_fd */ + "extattr_delete_fd", /* 312 = extattr_delete_fd */ + "extattr_set_link", /* 313 = extattr_set_link */ + "extattr_get_link", /* 314 = extattr_get_link */ + "extattr_delete_link", /* 315 = extattr_delete_link */ + "extattr_list_fd", /* 316 = extattr_list_fd */ + "extattr_list_file", /* 317 = extattr_list_file */ + "extattr_list_link", /* 318 = extattr_list_link */ + "extattrctl", /* 319 = extattrctl */ + "extattr_set_file", /* 320 = extattr_set_file */ + "extattr_get_file", /* 321 = extattr_get_file */ + "extattr_delete_file", /* 322 = extattr_delete_file */ +#else + "#310 (unimplemented)", /* 310 = unimplemented */ + "#311 (unimplemented)", /* 311 = unimplemented */ + "#312 (unimplemented)", /* 312 = unimplemented */ + "#313 (unimplemented)", /* 313 = unimplemented */ + "#314 (unimplemented)", /* 314 = unimplemented */ + "#315 (unimplemented)", /* 315 = unimplemented */ + "#316 (unimplemented)", /* 316 = unimplemented */ + "#317 (unimplemented)", /* 317 = unimplemented */ + "#318 (unimplemented)", /* 318 = unimplemented */ + "#319 (unimplemented)", /* 319 = unimplemented */ + "#320 (unimplemented)", /* 320 = unimplemented */ + "#321 (unimplemented)", /* 321 = unimplemented */ + "#322 (unimplemented)", /* 322 = unimplemented */ +#endif +#ifdef ACL + "__acl_get_file", /* 323 = __acl_get_file */ + "__acl_set_file", /* 324 = __acl_set_file */ + "__acl_get_fd", /* 325 = __acl_get_fd */ + "__acl_set_fd", /* 326 = __acl_set_fd */ + "__acl_delete_file", /* 327 = __acl_delete_file */ + "__acl_delete_fd", /* 328 = __acl_delete_fd */ + "__acl_aclcheck_file", /* 329 = __acl_aclcheck_file */ + "__acl_aclcheck_fd", /* 330 = __acl_aclcheck_fd */ + "__acl_get_link", /* 331 = __acl_get_link */ + "__acl_set_link", /* 332 = __acl_set_link */ + "__acl_delete_link", /* 333 = __acl_delete_link */ + "__acl_aclcheck_link", /* 334 = __acl_aclcheck_link */ +#else + "#323 (unimplemented)", /* 323 = unimplemented */ + "#324 (unimplemented)", /* 324 = unimplemented */ + "#325 (unimplemented)", /* 325 = unimplemented */ + "#326 (unimplemented)", /* 326 = unimplemented */ + "#327 (unimplemented)", /* 327 = unimplemented */ + "#328 (unimplemented)", /* 328 = unimplemented */ + "#329 (unimplemented)", /* 329 = unimplemented */ + "#330 (unimplemented)", /* 330 = unimplemented */ + "#331 (unimplemented)", /* 331 = unimplemented */ + "#332 (unimplemented)", /* 332 = unimplemented */ + "#333 (unimplemented)", /* 333 = unimplemented */ + "#334 (unimplemented)", /* 334 = unimplemented */ +#endif +#ifdef MAC + "__mac_get_pid", /* 335 = __mac_get_pid */ + "__mac_get_proc", /* 336 = __mac_get_proc */ + "__mac_set_proc", /* 337 = __mac_set_proc */ + "__mac_get_fd", /* 338 = __mac_get_fd */ + "__mac_get_file", /* 339 = __mac_get_file */ + "__mac_get_link", /* 340 = __mac_get_link */ + "__mac_set_fd", /* 341 = __mac_set_fd */ + "__mac_set_file", /* 342 = __mac_set_file */ + "__mac_set_link", /* 343 = __mac_set_link */ + "mac_syscall", /* 344 = mac_syscall */ +#else + "#335 (unimplemented)", /* 335 = unimplemented */ + "#336 (unimplemented)", /* 336 = unimplemented */ + "#337 (unimplemented)", /* 337 = unimplemented */ + "#338 (unimplemented)", /* 338 = unimplemented */ + "#339 (unimplemented)", /* 339 = unimplemented */ + "#340 (unimplemented)", /* 340 = unimplemented */ + "#341 (unimplemented)", /* 341 = unimplemented */ + "#342 (unimplemented)", /* 342 = unimplemented */ + "#343 (unimplemented)", /* 343 = unimplemented */ + "#344 (unimplemented)", /* 344 = unimplemented */ +#endif + /* NUMBER OF SYSCALLS: 344 */ }; diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index cde8c31..bd1cb96 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -539,13 +539,13 @@ 271 STD { int sys_mlockall(int flags); } 272 STD { int sys_munlockall(void); } 273 STD { int sys_getpeereid(int fdes, uid_t *euid, gid_t *egid); } -274 UNIMPL sys_extattrctl -275 UNIMPL sys_extattr_set_file -276 UNIMPL sys_extattr_get_file -277 UNIMPL sys_extattr_delete_file -278 UNIMPL sys_extattr_set_fd -279 UNIMPL sys_extattr_get_fd -280 UNIMPL sys_extattr_delete_fd +274 UNIMPL +275 UNIMPL +276 UNIMPL +277 UNIMPL +278 UNIMPL +279 UNIMPL +280 UNIMPL 281 STD { int sys_getresuid(uid_t *ruid, uid_t *euid, \ uid_t *suid); } 282 STD { int sys_setresuid(uid_t ruid, uid_t euid, \ @@ -618,3 +618,131 @@ 308 STD { int sys_fstatfs(int fd, struct statfs *buf); } 309 STD { int sys_fhstatfs(const fhandle_t *fhp, \ struct statfs *buf); } +#ifdef EXTATTR +310 STD { int sys_extattr_set_fd(int fd, \ + int attrnamespace, const char *attrname, \ + void *data, size_t nbytes); } +311 STD { ssize_t sys_extattr_get_fd(int fd, \ + int attrnamespace, const char *attrname, \ + void *data, size_t nbytes); } +312 STD { int sys_extattr_delete_fd(int fd, \ + int attrnamespace, \ + const char *attrname); } +313 STD { int sys_extattr_set_link( \ + const char *path, int attrnamespace, \ + const char *attrname, void *data, \ + size_t nbytes); } +314 STD { ssize_t sys_extattr_get_link( \ + const char *path, int attrnamespace, \ + const char *attrname, void *data, \ + size_t nbytes); } +315 STD { int sys_extattr_delete_link( \ + const char *path, int attrnamespace, \ + const char *attrname); } +316 STD { ssize_t sys_extattr_list_fd(int fd, \ + int attrnamespace, void *data, \ + size_t nbytes); } +317 STD { ssize_t sys_extattr_list_file( \ + const char *path, int attrnamespace, \ + void *data, size_t nbytes); } +318 STD { ssize_t sys_extattr_list_link( \ + const char *path, int attrnamespace, \ + void *data, size_t nbytes); } +319 STD { int sys_extattrctl(const char *path, int cmd, \ + const char *filename, int attrnamespace, \ + const char *attrname); } +320 STD { int sys_extattr_set_file( \ + const char *path, int attrnamespace, \ + const char *attrname, void *data, \ + size_t nbytes); } +321 STD { ssize_t sys_extattr_get_file( \ + const char *path, int attrnamespace, \ + const char *attrname, void *data, \ + size_t nbytes); } +322 STD { int sys_extattr_delete_file( \ + const char *path, int attrnamespace, \ + const char *attrname, void *data, \ + size_t nbytes); } +#else +310 UNIMPL +311 UNIMPL +312 UNIMPL +313 UNIMPL +314 UNIMPL +315 UNIMPL +316 UNIMPL +317 UNIMPL +318 UNIMPL +319 UNIMPL +320 UNIMPL +321 UNIMPL +322 UNIMPL +#endif +#ifdef ACL +323 STD { int sys___acl_get_file(const char *path, \ + acl_type_t type, struct acl *aclp); } +324 STD { int sys___acl_set_file(const char *path, \ + acl_type_t type, struct acl *aclp); } +325 STD { int sys___acl_get_fd(int filedes, acl_type_t type, \ + struct acl *aclp); } +326 STD { int sys___acl_set_fd(int filedes, acl_type_t type, \ + struct acl *aclp); } +327 STD { int sys___acl_delete_file(const char *path, \ + acl_type_t type); } +328 STD { int sys___acl_delete_fd(int filedes, \ + acl_type_t type); } +329 STD { int sys___acl_aclcheck_file(const char *path, \ + acl_type_t type, struct acl *aclp); } +330 STD { int sys___acl_aclcheck_fd(int filedes, \ + acl_type_t type, struct acl *aclp); } +331 STD { int sys___acl_get_link(const char *path, \ + acl_type_t type, struct acl *aclp); } +332 STD { int sys___acl_set_link(const char *path, \ + acl_type_t type, struct acl *aclp); } +333 STD { int sys___acl_delete_link(const char *path, \ + acl_type_t type); } +334 STD { int sys___acl_aclcheck_link(const char *path, \ + acl_type_t type, struct acl *aclp); } +#else +323 UNIMPL +324 UNIMPL +325 UNIMPL +326 UNIMPL +327 UNIMPL +328 UNIMPL +329 UNIMPL +330 UNIMPL +331 UNIMPL +332 UNIMPL +333 UNIMPL +334 UNIMPL +#endif +#ifdef MAC +335 STD { int sys___mac_get_pid(pid_t pid, struct mac *mac_p); } +336 STD { int sys___mac_get_proc(struct mac *mac_p); } +337 STD { int sys___mac_set_proc(struct mac *mac_p); } +338 STD { int sys___mac_get_fd(int fd, struct mac *mac_p); } +339 STD { int sys___mac_get_file(const char *path_p, \ + struct mac *mac_p); } +340 STD { int sys___mac_get_link(const char *path_p, \ + struct mac *mac_p); } +341 STD { int sys___mac_set_fd(int fd, struct mac *mac_p); } +342 STD { int sys___mac_set_file(const char *path_p, \ + struct mac *mac_p); } +343 STD { int sys___mac_set_link(const char *path_p, \ + struct mac *mac_p); } +344 STD { int sys_mac_syscall(const char *policy, int call, \ + void *arg); } +#else +335 UNIMPL +336 UNIMPL +337 UNIMPL +338 UNIMPL +339 UNIMPL +340 UNIMPL +341 UNIMPL +342 UNIMPL +343 UNIMPL +344 UNIMPL +#endif +; NUMBER OF SYSCALLS: 344 diff --git a/sys/kern/sysv_msg.c b/sys/kern/sysv_msg.c index 7e9cde8..88c4b8d 100644 --- a/sys/kern/sysv_msg.c +++ b/sys/kern/sysv_msg.c @@ -30,6 +30,10 @@ #include #include +#ifdef MAC +#include +#endif + #ifdef MSG_DEBUG #define DPRINTF(x) printf x #else @@ -42,7 +46,7 @@ struct msg *free_msghdrs; /* list of free msg headers */ char *msgpool; /* MSGMAX byte long msg buffer pool */ struct msgmap *msgmaps; /* MSGSEG msgmap structures */ struct msg *msghdrs; /* MSGTQL msg headers */ -struct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */ +struct msqid_kernel *msqids; /* MSGMNI msqid_kernel struct's */ void msg_freehdr(struct msg *); @@ -62,7 +66,9 @@ msginit(void) i <<= 1; if (i != msginfo.msgssz) - panic("msginfo.msgssz %d not a small power of 2", msginfo.msgssz); + panic("msginfo.msgssz %d not a small power of 2", + msginfo.msgssz); + if (msginfo.msgseg > 32767) panic("msginfo.msgseg %d > 32767", msginfo.msgseg); @@ -74,6 +80,7 @@ msginit(void) msgmaps[i-1].next = i; msgmaps[i].next = -1; /* implies entry is available */ } + free_msgmaps = 0; nfree_msgmaps = msginfo.msgseg; @@ -85,15 +92,22 @@ msginit(void) if (i > 0) msghdrs[i-1].msg_next = &msghdrs[i]; msghdrs[i].msg_next = NULL; +#ifdef MAC + mac_sysvmsg_init(&msghdrs[i]); +#endif } + free_msghdrs = &msghdrs[0]; if (msqids == NULL) panic("msqids is NULL"); for (i = 0; i < msginfo.msgmni; i++) { - msqids[i].msg_qbytes = 0; /* implies entry is available */ - msqids[i].msg_perm.seq = 0; /* reset to a known value */ + msqids[i].u.msg_qbytes = 0; /* implies entry is available */ + msqids[i].u.msg_perm.seq = 0; /* reset to a known value */ +#ifdef MAC + mac_sysvmsq_init(&msqids[i]); +#endif } } @@ -102,7 +116,6 @@ msg_freehdr(struct msg *msghdr) { while (msghdr->msg_ts > 0) { short next; - #ifdef DIAGNOSTIC if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg) panic("msghdr->msg_spot out of range"); @@ -121,6 +134,9 @@ msg_freehdr(struct msg *msghdr) if (msghdr->msg_spot != -1) panic("msghdr->msg_spot != -1"); #endif +#ifdef MAC + mac_sysvmsg_cleanup(msghdr); +#endif msghdr->msg_next = free_msghdrs; free_msghdrs = msghdr; } @@ -144,7 +160,8 @@ msgctl1(struct proc *p, int msqid, int cmd, caddr_t buf, int (*ds_copyout)(const void *, void *, size_t)) { struct ucred *cred = p->p_ucred; - struct msqid_ds msqbuf, *msqptr; + struct msqid_ds msqbuf; + struct msqid_kernel *msqkptr; struct msg *msghdr; int ix, error = 0; @@ -158,50 +175,77 @@ msgctl1(struct proc *p, int msqid, int cmd, caddr_t buf, return (EINVAL); } - msqptr = &msqids[ix]; + msqkptr = &msqids[ix]; - if (msqptr->msg_qbytes == 0) { + if (msqkptr->u.msg_qbytes == 0) { DPRINTF(("no such msqid\n")); return (EINVAL); } - if (msqptr->msg_perm.seq != IPCID_TO_SEQ(msqid)) { + if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(msqid)) { DPRINTF(("wrong sequence number\n")); return (EINVAL); } +#ifdef MAC + error = mac_sysvmsq_check_msqctl(cred, msqkptr, cmd); + if (error) + return (error); +#endif + switch (cmd) { case IPC_RMID: - if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M)) != 0) + if ((error = ipcperm(cred, &msqkptr->u.msg_perm, IPC_M)) != 0) return (error); + +#ifdef MAC + /* + * Check that the process has MAC access permissions to + * individual msghdrs. Note: We need to do this in a separate + * loop because the actual loop alters the msq/msghdr info as + * it progresses, and there is no going back if half the way + * we discover that the process cannot free a certain msghdr. + * The msq will get into an inconsistent state. + */ + for (msghdr = msqkptr->u.msg_first; msghdr != NULL; + msghdr = msghdr->msg_next) { + error = mac_sysvmsq_check_msgrmid(cred, msghdr); + if (error) + return (error); + } +#endif + /* Free the message headers */ - msghdr = msqptr->msg_first; + msghdr = msqkptr->u.msg_first; while (msghdr != NULL) { struct msg *msghdr_tmp; /* Free the segments of each message */ - msqptr->msg_cbytes -= msghdr->msg_ts; - msqptr->msg_qnum--; + msqkptr->u.msg_cbytes -= msghdr->msg_ts; + msqkptr->u.msg_qnum--; msghdr_tmp = msghdr; msghdr = msghdr->msg_next; msg_freehdr(msghdr_tmp); } #ifdef DIAGNOSTIC - if (msqptr->msg_cbytes != 0) + if (msqkptr->u.msg_cbytes != 0) panic("sys_msgctl: msg_cbytes is screwed up"); - if (msqptr->msg_qnum != 0) + if (msqkptr->u.msg_qnum != 0) panic("sys_msgctl: msg_qnum is screwed up"); #endif - msqptr->msg_qbytes = 0; /* Mark it as free */ - wakeup(msqptr); +#ifdef MAC + mac_sysvmsq_cleanup(msqkptr); +#endif + msqkptr->u.msg_qbytes = 0; /* Mark it as free */ + wakeup(msqkptr); break; case IPC_SET: - if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M))) + if ((error = ipcperm(cred, &msqkptr->u.msg_perm, IPC_M))) return (error); if ((error = ds_copyin(buf, &msqbuf, sizeof(msqbuf))) != 0) return (error); - if (msqbuf.msg_qbytes > msqptr->msg_qbytes && + if (msqbuf.msg_qbytes > msqkptr->u.msg_qbytes && cred->cr_uid != 0) return (EPERM); if (msqbuf.msg_qbytes > msginfo.msgmnb) { @@ -214,20 +258,20 @@ msgctl1(struct proc *p, int msqid, int cmd, caddr_t buf, DPRINTF(("can't reduce msg_qbytes to 0\n")); return (EINVAL); /* non-standard errno! */ } - msqptr->msg_perm.uid = msqbuf.msg_perm.uid; - msqptr->msg_perm.gid = msqbuf.msg_perm.gid; - msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) | + msqkptr->u.msg_perm.uid = msqbuf.msg_perm.uid; + msqkptr->u.msg_perm.gid = msqbuf.msg_perm.gid; + msqkptr->u.msg_perm.mode = (msqkptr->u.msg_perm.mode & ~0777) | (msqbuf.msg_perm.mode & 0777); - msqptr->msg_qbytes = msqbuf.msg_qbytes; - msqptr->msg_ctime = time_second; + msqkptr->u.msg_qbytes = msqbuf.msg_qbytes; + msqkptr->u.msg_ctime = time_second; break; case IPC_STAT: - if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_R))) { + if ((error = ipcperm(cred, &msqkptr->u.msg_perm, IPC_R))) { DPRINTF(("requester doesn't have read access\n")); return (error); } - error = ds_copyout(msqptr, buf, sizeof(struct msqid_ds)); + error = ds_copyout(&msqkptr->u, buf, sizeof(struct msqid_ds)); break; default: @@ -248,15 +292,15 @@ sys_msgget(struct proc *p, void *v, register_t *retval) int key = SCARG(uap, key); int msgflg = SCARG(uap, msgflg); struct ucred *cred = p->p_ucred; - struct msqid_ds *msqptr = NULL; + struct msqid_kernel *msqkptr = NULL; DPRINTF(("msgget(0x%x, 0%o)\n", key, msgflg)); if (key != IPC_PRIVATE) { for (msqid = 0; msqid < msginfo.msgmni; msqid++) { - msqptr = &msqids[msqid]; - if (msqptr->msg_qbytes != 0 && - msqptr->msg_perm.key == key) + msqkptr = &msqids[msqid]; + if (msqkptr->u.msg_qbytes != 0 && + msqkptr->u.msg_perm.key == key) break; } if (msqid < msginfo.msgmni) { @@ -265,11 +309,17 @@ sys_msgget(struct proc *p, void *v, register_t *retval) DPRINTF(("not exclusive\n")); return (EEXIST); } - if ((eval = ipcperm(cred, &msqptr->msg_perm, msgflg & 0700 ))) { + if ((eval = ipcperm(cred, &msqkptr->u.msg_perm, + msgflg & 0700 ))) { DPRINTF(("requester doesn't have 0%o access\n", msgflg & 0700)); return (eval); } +#ifdef MAC + eval = mac_sysvmsq_check_msqget(cred, msqkptr); + if (eval) + return (eval); +#endif goto found; } } @@ -283,9 +333,9 @@ sys_msgget(struct proc *p, void *v, register_t *retval) * they are copying the message in/out. We can't * re-use the entry until they release it. */ - msqptr = &msqids[msqid]; - if (msqptr->msg_qbytes == 0 && - (msqptr->msg_perm.mode & MSG_LOCKED) == 0) + msqkptr = &msqids[msqid]; + if (msqkptr->u.msg_qbytes == 0 && + (msqkptr->u.msg_perm.mode & MSG_LOCKED) == 0) break; } if (msqid == msginfo.msgmni) { @@ -293,24 +343,28 @@ sys_msgget(struct proc *p, void *v, register_t *retval) return (ENOSPC); } DPRINTF(("msqid %d is available\n", msqid)); - msqptr->msg_perm.key = key; - msqptr->msg_perm.cuid = cred->cr_uid; - msqptr->msg_perm.uid = cred->cr_uid; - msqptr->msg_perm.cgid = cred->cr_gid; - msqptr->msg_perm.gid = cred->cr_gid; - msqptr->msg_perm.mode = (msgflg & 0777); + msqkptr->u.msg_perm.key = key; + msqkptr->u.msg_perm.cuid = cred->cr_uid; + msqkptr->u.msg_perm.uid = cred->cr_uid; + msqkptr->u.msg_perm.cgid = cred->cr_gid; + msqkptr->u.msg_perm.gid = cred->cr_gid; + msqkptr->u.msg_perm.mode = (msgflg & 0777); /* Make sure that the returned msqid is unique */ - msqptr->msg_perm.seq = (msqptr->msg_perm.seq + 1) & 0x7fff; - msqptr->msg_first = NULL; - msqptr->msg_last = NULL; - msqptr->msg_cbytes = 0; - msqptr->msg_qnum = 0; - msqptr->msg_qbytes = msginfo.msgmnb; - msqptr->msg_lspid = 0; - msqptr->msg_lrpid = 0; - msqptr->msg_stime = 0; - msqptr->msg_rtime = 0; - msqptr->msg_ctime = time_second; + msqkptr->u.msg_perm.seq = + (msqkptr->u.msg_perm.seq + 1) & 0x7fff; + msqkptr->u.msg_first = NULL; + msqkptr->u.msg_last = NULL; + msqkptr->u.msg_cbytes = 0; + msqkptr->u.msg_qnum = 0; + msqkptr->u.msg_qbytes = msginfo.msgmnb; + msqkptr->u.msg_lspid = 0; + msqkptr->u.msg_lrpid = 0; + msqkptr->u.msg_stime = 0; + msqkptr->u.msg_rtime = 0; + msqkptr->u.msg_ctime = time_second; +#ifdef MAC + mac_sysvmsq_create(cred, msqkptr); +#endif } else { DPRINTF(("didn't find it and wasn't asked to create it\n")); return (ENOENT); @@ -318,7 +372,7 @@ sys_msgget(struct proc *p, void *v, register_t *retval) found: /* Construct the unique msqid */ - *retval = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm); + *retval = IXSEQ_TO_IPCID(msqid, msqkptr->u.msg_perm); return (0); } @@ -337,7 +391,7 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) int msgflg = SCARG(uap, msgflg); int segs_needed, eval; struct ucred *cred = p->p_ucred; - struct msqid_ds *msqptr; + struct msqid_kernel *msqkptr; struct msg *msghdr; short next; @@ -352,21 +406,27 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) return (EINVAL); } - msqptr = &msqids[msqid]; - if (msqptr->msg_qbytes == 0) { + msqkptr = &msqids[msqid]; + if (msqkptr->u.msg_qbytes == 0) { DPRINTF(("no such message queue id\n")); return (EINVAL); } - if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) { + if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) { DPRINTF(("wrong sequence number\n")); return (EINVAL); } - if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_W))) { + if ((eval = ipcperm(cred, &msqkptr->u.msg_perm, IPC_W))) { DPRINTF(("requester doesn't have write access\n")); return (eval); } +#ifdef MAC + eval = mac_sysvmsq_check_msqsnd(cred, msqkptr); + if (eval) + return (eval); +#endif + segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz; DPRINTF(("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz, msginfo.msgssz, segs_needed)); @@ -378,16 +438,16 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) * (inside this loop in case msg_qbytes changes while we sleep) */ - if (msgsz > msqptr->msg_qbytes) { - DPRINTF(("msgsz > msqptr->msg_qbytes\n")); + if (msgsz > msqkptr->u.msg_qbytes) { + DPRINTF(("msgsz > msqkptr->u.msg_qbytes\n")); return (EINVAL); } - if (msqptr->msg_perm.mode & MSG_LOCKED) { + if (msqkptr->u.msg_perm.mode & MSG_LOCKED) { DPRINTF(("msqid is locked\n")); need_more_resources = 1; } - if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) { + if (msgsz + msqkptr->u.msg_cbytes > msqkptr->u.msg_qbytes) { DPRINTF(("msgsz + msg_cbytes > msg_qbytes\n")); need_more_resources = 1; } @@ -409,22 +469,22 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) return (EAGAIN); } - if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) { + if ((msqkptr->u.msg_perm.mode & MSG_LOCKED) != 0) { DPRINTF(("we don't own the msqid_ds\n")); we_own_it = 0; } else { /* Force later arrivals to wait for our request */ DPRINTF(("we own the msqid_ds\n")); - msqptr->msg_perm.mode |= MSG_LOCKED; + msqkptr->u.msg_perm.mode |= MSG_LOCKED; we_own_it = 1; } DPRINTF(("goodnight\n")); - eval = tsleep(msqptr, (PZERO - 4) | PCATCH, + eval = tsleep(msqkptr, (PZERO - 4) | PCATCH, "msgwait", 0); DPRINTF(("good morning, eval=%d\n", eval)); if (we_own_it) - msqptr->msg_perm.mode &= ~MSG_LOCKED; + msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; if (eval != 0) { DPRINTF(("msgsnd: interrupted system call\n")); return (EINTR); @@ -434,7 +494,7 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) * Make sure that the msq queue still exists */ - if (msqptr->msg_qbytes == 0) { + if (msqkptr->u.msg_qbytes == 0) { DPRINTF(("msqid deleted\n")); return (EIDRM); } @@ -451,11 +511,11 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) */ #ifdef DIAGNOSTIC - if (msqptr->msg_perm.mode & MSG_LOCKED) + if (msqkptr->u.msg_perm.mode & MSG_LOCKED) panic("msg_perm.mode & MSG_LOCKED"); if (segs_needed > nfree_msgmaps) panic("segs_needed > nfree_msgmaps"); - if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) + if (msgsz + msqkptr->u.msg_cbytes > msqkptr->u.msg_qbytes) panic("msgsz + msg_cbytes > msg_qbytes"); if (free_msghdrs == NULL) panic("no more msghdrs"); @@ -467,10 +527,10 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) */ #ifdef DIAGNOSTIC - if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) + if ((msqkptr->u.msg_perm.mode & MSG_LOCKED) != 0) panic("msqid_ds is already locked"); #endif - msqptr->msg_perm.mode |= MSG_LOCKED; + msqkptr->u.msg_perm.mode |= MSG_LOCKED; /* * Allocate a message header @@ -480,6 +540,14 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) free_msghdrs = msghdr->msg_next; msghdr->msg_spot = -1; msghdr->msg_ts = msgsz; +#ifdef MAC + /* + * XXXMAC: Should the mac_sysvmsq_check_msgmsq check follow here + * immediately? Or, should it be checked just before the msg is + * enqueued in the msgq (as it is done now)? + */ + mac_sysvmsg_create(cred, msqkptr, msghdr); +#endif /* * Allocate space for the message @@ -515,8 +583,8 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) sizeof(msghdr->msg_type))) != 0) { DPRINTF(("error %d copying the message type\n", eval)); msg_freehdr(msghdr); - msqptr->msg_perm.mode &= ~MSG_LOCKED; - wakeup(msqptr); + msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; + wakeup(msqkptr); return (eval); } user_msgp += sizeof(msghdr->msg_type); @@ -527,8 +595,8 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) if (msghdr->msg_type < 1) { msg_freehdr(msghdr); - msqptr->msg_perm.mode &= ~MSG_LOCKED; - wakeup(msqptr); + msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; + wakeup(msqkptr); DPRINTF(("mtype (%d) < 1\n", msghdr->msg_type)); return (EINVAL); } @@ -555,8 +623,8 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) DPRINTF(("error %d copying in message segment\n", eval)); msg_freehdr(msghdr); - msqptr->msg_perm.mode &= ~MSG_LOCKED; - wakeup(msqptr); + msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; + wakeup(msqkptr); return (eval); } msgsz -= tlen; @@ -571,37 +639,57 @@ sys_msgsnd(struct proc *p, void *v, register_t *retval) * We've got the message. Unlock the msqid_ds. */ - msqptr->msg_perm.mode &= ~MSG_LOCKED; + msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; /* * Make sure that the msqid_ds is still allocated. */ - if (msqptr->msg_qbytes == 0) { + if (msqkptr->u.msg_qbytes == 0) { msg_freehdr(msghdr); - wakeup(msqptr); + wakeup(msqkptr); return (EIDRM); } +#ifdef MAC + /* + * Note: Since the task/thread allocates the msghdr and usually + * primes it with its own MAC label, for a majority of policies, it + * won't be necessary to check whether the msghdr has access + * permissions to the msgq. The mac_sysvmsq_check_msqsnd check would + * suffice in that case. However, this hook may be required where + * individual policies derive a non-identical label for the msghdr + * from the current thread label and may want to check the msghdr + * enqueue permissions, along with read/write permissions to the + * msgq. + */ + eval = mac_sysvmsq_check_msgmsq(cred, msghdr, msqkptr); + if (eval) { + msg_freehdr(msghdr); + wakeup(msqkptr); + return (eval); + } +#endif + /* * Put the message into the queue */ - if (msqptr->msg_first == NULL) { - msqptr->msg_first = msghdr; - msqptr->msg_last = msghdr; + if (msqkptr->u.msg_first == NULL) { + msqkptr->u.msg_first = msghdr; + msqkptr->u.msg_last = msghdr; } else { - msqptr->msg_last->msg_next = msghdr; - msqptr->msg_last = msghdr; + msqkptr->u.msg_last->msg_next = msghdr; + msqkptr->u.msg_last = msghdr; } - msqptr->msg_last->msg_next = NULL; + msqkptr->u.msg_last->msg_next = NULL; - msqptr->msg_cbytes += msghdr->msg_ts; - msqptr->msg_qnum++; - msqptr->msg_lspid = p->p_p->ps_mainproc->p_pid; - msqptr->msg_stime = time_second; + msqkptr->u.msg_cbytes += msghdr->msg_ts; + msqkptr->u.msg_qnum++; + msqkptr->u.msg_lspid = p->p_p->ps_mainproc->p_pid; + msqkptr->u.msg_stime = time_second; - wakeup(msqptr); + wakeup(msqkptr); *retval = 0; return (0); } @@ -623,7 +711,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) int msgflg = SCARG(uap, msgflg); size_t len; struct ucred *cred = p->p_ucred; - struct msqid_ds *msqptr; + struct msqid_kernel *msqkptr; struct msg *msghdr; int eval; short next; @@ -639,17 +727,17 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) return (EINVAL); } - msqptr = &msqids[msqid]; - if (msqptr->msg_qbytes == 0) { + msqkptr = &msqids[msqid]; + if (msqkptr->u.msg_qbytes == 0) { DPRINTF(("no such message queue id\n")); return (EINVAL); } - if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) { + if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) { DPRINTF(("wrong sequence number\n")); return (EINVAL); } - if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) { + if ((eval = ipcperm(cred, &msqkptr->u.msg_perm, IPC_R))) { DPRINTF(("requester doesn't have read access\n")); return (eval); } @@ -662,10 +750,16 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) } #endif +#ifdef MAC + eval = mac_sysvmsq_check_msqrcv(cred, msqkptr); + if (eval) + return (eval); +#endif + msghdr = NULL; while (msghdr == NULL) { if (msgtyp == 0) { - msghdr = msqptr->msg_first; + msghdr = msqkptr->u.msg_first; if (msghdr != NULL) { if (msgsz < msghdr->msg_ts && (msgflg & MSG_NOERROR) == 0) { @@ -674,13 +768,19 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) msgsz, msghdr->msg_ts)); return (E2BIG); } - if (msqptr->msg_first == msqptr->msg_last) { - msqptr->msg_first = NULL; - msqptr->msg_last = NULL; +#ifdef MAC + eval = mac_sysvmsq_check_msgrcv(cred, msghdr); + if (eval) + return (eval); +#endif + if (msqkptr->u.msg_first == + msqkptr->u.msg_last) { + msqkptr->u.msg_first = NULL; + msqkptr->u.msg_last = NULL; } else { - msqptr->msg_first = msghdr->msg_next; + msqkptr->u.msg_first = msghdr->msg_next; #ifdef DIAGNOSTIC - if (msqptr->msg_first == NULL) + if (msqkptr->u.msg_first == NULL) panic("msg_first/last screwed up #1"); #endif } @@ -689,7 +789,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) struct msg *previous; struct msg **prev; - for (previous = NULL, prev = &msqptr->msg_first; + for (previous = NULL, prev = &msqkptr->u.msg_first; (msghdr = *prev) != NULL; previous = msghdr, prev = &msghdr->msg_next) { /* @@ -714,25 +814,31 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) msgsz, msghdr->msg_ts)); return (E2BIG); } +#ifdef MAC + eval = mac_sysvmsq_check_msgrcv(cred, + msghdr); + if (eval) + return (eval); +#endif *prev = msghdr->msg_next; - if (msghdr == msqptr->msg_last) { + if (msghdr == msqkptr->u.msg_last) { if (previous == NULL) { #ifdef DIAGNOSTIC if (prev != - &msqptr->msg_first) + &msqkptr->u.msg_first) panic("msg_first/last screwed up #2"); #endif - msqptr->msg_first = + msqkptr->u.msg_first = NULL; - msqptr->msg_last = + msqkptr->u.msg_last = NULL; } else { #ifdef DIAGNOSTIC if (prev == - &msqptr->msg_first) + &msqkptr->u.msg_first) panic("msg_first/last screwed up #3"); #endif - msqptr->msg_last = + msqkptr->u.msg_last = previous; } } @@ -765,7 +871,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) */ DPRINTF(("msgrcv: goodnight\n")); - eval = tsleep(msqptr, (PZERO - 4) | PCATCH, "msgwait", + eval = tsleep(msqkptr, (PZERO - 4) | PCATCH, "msgwait", 0); DPRINTF(("msgrcv: good morning (eval=%d)\n", eval)); @@ -778,8 +884,9 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) * Make sure that the msq queue still exists */ - if (msqptr->msg_qbytes == 0 || - msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) { + if (msqkptr->u.msg_qbytes == 0 || + msqkptr->u.msg_perm.seq != + IPCID_TO_SEQ(SCARG(uap, msqid))) { DPRINTF(("msqid deleted\n")); return (EIDRM); } @@ -791,10 +898,10 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) * First, do the bookkeeping (before we risk being interrupted). */ - msqptr->msg_cbytes -= msghdr->msg_ts; - msqptr->msg_qnum--; - msqptr->msg_lrpid = p->p_p->ps_mainproc->p_pid; - msqptr->msg_rtime = time_second; + msqkptr->u.msg_cbytes -= msghdr->msg_ts; + msqkptr->u.msg_qnum--; + msqkptr->u.msg_lrpid = p->p_p->ps_mainproc->p_pid; + msqkptr->u.msg_rtime = time_second; /* * Make msgsz the actual amount that we'll be returning. @@ -816,7 +923,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) if (eval != 0) { DPRINTF(("error (%d) copying out message type\n", eval)); msg_freehdr(msghdr); - wakeup(msqptr); + wakeup(msqkptr); return (eval); } user_msgp += sizeof(msghdr->msg_type); @@ -845,7 +952,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) DPRINTF(("error (%d) copying out message segment\n", eval)); msg_freehdr(msghdr); - wakeup(msqptr); + wakeup(msqkptr); return (eval); } user_msgp += tlen; @@ -857,7 +964,7 @@ sys_msgrcv(struct proc *p, void *v, register_t *retval) */ msg_freehdr(msghdr); - wakeup(msqptr); + wakeup(msqkptr); *retval = msgsz; return (0); } diff --git a/sys/kern/sysv_sem.c b/sys/kern/sysv_sem.c index 830c86b..993bbdb 100644 --- a/sys/kern/sysv_sem.c +++ b/sys/kern/sysv_sem.c @@ -40,6 +40,10 @@ #include #include +#ifdef MAC +#include +#endif + #ifdef SEM_DEBUG #define DPRINTF(x) printf x #else @@ -48,9 +52,9 @@ int semtot = 0; int semutot = 0; -struct semid_ds **sema; /* semaphore id list */ +struct semid_kernel **sema; /* semaphore id list */ SLIST_HEAD(, sem_undo) semu_list; /* list of undo structures */ -struct pool sema_pool; /* pool for struct semid_ds */ +struct pool sema_pool; /* pool for struct semid_kernel */ struct pool semu_pool; /* pool for struct sem_undo (SEMUSZ) */ unsigned short *semseqs; /* array of sem sequence numbers */ @@ -61,12 +65,11 @@ void semundo_clear(int, int); void seminit(void) { - - pool_init(&sema_pool, sizeof(struct semid_ds), 0, 0, 0, "semapl", + pool_init(&sema_pool, sizeof(struct semid_kernel), 0, 0, 0, "semapl", &pool_allocator_nointr); pool_init(&semu_pool, SEMUSZ, 0, 0, 0, "semupl", &pool_allocator_nointr); - sema = malloc(seminfo.semmni * sizeof(struct semid_ds *), + sema = malloc(seminfo.semmni * sizeof(struct semid_kernel *), M_SEM, M_WAITOK|M_ZERO); semseqs = malloc(seminfo.semmni * sizeof(unsigned short), M_SEM, M_WAITOK|M_ZERO); @@ -257,7 +260,7 @@ semctl1(struct proc *p, int semid, int semnum, int cmd, union semun *arg, struct ucred *cred = p->p_ucred; int i, ix, error = 0; struct semid_ds sbuf; - struct semid_ds *semaptr; + struct semid_kernel *semakptr; DPRINTF(("call to semctl(%d, %d, %d, %p)\n", semid, semnum, cmd, arg)); @@ -265,71 +268,83 @@ semctl1(struct proc *p, int semid, int semnum, int cmd, union semun *arg, if (ix < 0 || ix >= seminfo.semmni) return (EINVAL); - if ((semaptr = sema[ix]) == NULL || - semaptr->sem_perm.seq != IPCID_TO_SEQ(semid)) + if ((semakptr = sema[ix]) == NULL || + semakptr->u.sem_perm.seq != IPCID_TO_SEQ(semid)) return (EINVAL); +#ifdef MAC + error = mac_sysvsem_check_semctl(cred, semakptr, cmd); + if (error) + return (error); +#endif + switch (cmd) { case IPC_RMID: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_M)) != 0) return (error); - semaptr->sem_perm.cuid = cred->cr_uid; - semaptr->sem_perm.uid = cred->cr_uid; - semtot -= semaptr->sem_nsems; - free(semaptr->sem_base, M_SEM); - pool_put(&sema_pool, semaptr); + semakptr->u.sem_perm.cuid = cred->cr_uid; + semakptr->u.sem_perm.uid = cred->cr_uid; +#ifdef MAC + mac_sysvsem_cleanup(semakptr); + mac_sysvsem_destroy(semakptr); +#endif + semtot -= semakptr->u.sem_nsems; + free(semakptr->u.sem_base, M_SEM); + pool_put(&sema_pool, semakptr); sema[ix] = NULL; semundo_clear(ix, -1); wakeup(&sema[ix]); break; case IPC_SET: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_M))) return (error); if ((error = ds_copyin(arg->buf, &sbuf, sizeof(sbuf))) != 0) return (error); - semaptr->sem_perm.uid = sbuf.sem_perm.uid; - semaptr->sem_perm.gid = sbuf.sem_perm.gid; - semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) | + semakptr->u.sem_perm.uid = sbuf.sem_perm.uid; + semakptr->u.sem_perm.gid = sbuf.sem_perm.gid; + semakptr->u.sem_perm.mode = + (semakptr->u.sem_perm.mode & ~0777) | (sbuf.sem_perm.mode & 0777); - semaptr->sem_ctime = time_second; + semakptr->u.sem_ctime = time_second; break; case IPC_STAT: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - error = ds_copyout(semaptr, arg->buf, sizeof(struct semid_ds)); + error = ds_copyout(&semakptr->u, arg->buf, + sizeof(struct semid_ds)); break; case GETNCNT: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - if (semnum < 0 || semnum >= semaptr->sem_nsems) + if (semnum < 0 || semnum >= semakptr->u.sem_nsems) return (EINVAL); - *retval = semaptr->sem_base[semnum].semncnt; + *retval = semakptr->u.sem_base[semnum].semncnt; break; case GETPID: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - if (semnum < 0 || semnum >= semaptr->sem_nsems) + if (semnum < 0 || semnum >= semakptr->u.sem_nsems) return (EINVAL); - *retval = semaptr->sem_base[semnum].sempid; + *retval = semakptr->u.sem_base[semnum].sempid; break; case GETVAL: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - if (semnum < 0 || semnum >= semaptr->sem_nsems) + if (semnum < 0 || semnum >= semakptr->u.sem_nsems) return (EINVAL); - *retval = semaptr->sem_base[semnum].semval; + *retval = semakptr->u.sem_base[semnum].semval; break; case GETALL: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - for (i = 0; i < semaptr->sem_nsems; i++) { - error = ds_copyout(&semaptr->sem_base[i].semval, + for (i = 0; i < semakptr->u.sem_nsems; i++) { + error = ds_copyout(&semakptr->u.sem_base[i].semval, &arg->array[i], sizeof(arg->array[0])); if (error != 0) break; @@ -337,29 +352,29 @@ semctl1(struct proc *p, int semid, int semnum, int cmd, union semun *arg, break; case GETZCNT: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_R))) return (error); - if (semnum < 0 || semnum >= semaptr->sem_nsems) + if (semnum < 0 || semnum >= semakptr->u.sem_nsems) return (EINVAL); - *retval = semaptr->sem_base[semnum].semzcnt; + *retval = semakptr->u.sem_base[semnum].semzcnt; break; case SETVAL: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_W))) return (error); - if (semnum < 0 || semnum >= semaptr->sem_nsems) + if (semnum < 0 || semnum >= semakptr->u.sem_nsems) return (EINVAL); - semaptr->sem_base[semnum].semval = arg->val; + semakptr->u.sem_base[semnum].semval = arg->val; semundo_clear(ix, semnum); wakeup(&sema[ix]); break; case SETALL: - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_W))) return (error); - for (i = 0; i < semaptr->sem_nsems; i++) { + for (i = 0; i < semakptr->u.sem_nsems; i++) { error = ds_copyin(&arg->array[i], - &semaptr->sem_base[i].semval, + &semakptr->u.sem_base[i].semval, sizeof(arg->array[0])); if (error != 0) break; @@ -387,7 +402,7 @@ sys_semget(struct proc *p, void *v, register_t *retval) int key = SCARG(uap, key); int nsems = SCARG(uap, nsems); int semflg = SCARG(uap, semflg); - struct semid_ds *semaptr, *semaptr_new = NULL; + struct semid_kernel *semakptr, *semakptr_new = NULL; struct ucred *cred = p->p_ucred; DPRINTF(("semget(0x%x, %d, 0%o)\n", key, nsems, semflg)); @@ -408,20 +423,22 @@ sys_semget(struct proc *p, void *v, register_t *retval) nsems, seminfo.semmns - semtot)); return (ENOSPC); } - semaptr_new = pool_get(&sema_pool, PR_WAITOK); - semaptr_new->sem_base = malloc(nsems * sizeof(struct sem), + semakptr_new = pool_get(&sema_pool, PR_WAITOK); + semakptr_new->u.sem_base = malloc(nsems * sizeof(struct sem), M_SEM, M_WAITOK|M_ZERO); } if (key != IPC_PRIVATE) { - for (semid = 0, semaptr = NULL; semid < seminfo.semmni; semid++) { - if ((semaptr = sema[semid]) != NULL && - semaptr->sem_perm.key == key) { + for (semid = 0, semakptr = NULL; + semid < seminfo.semmni; semid++) { + if ((semakptr = sema[semid]) != NULL && + semakptr->u.sem_perm.key == key) { DPRINTF(("found public key\n")); - if ((error = ipcperm(cred, &semaptr->sem_perm, - semflg & 0700))) + if ((error = ipcperm(cred, + &semakptr->u.sem_perm, semflg & 0700))) goto error; - if (nsems > 0 && semaptr->sem_nsems < nsems) { + if (nsems > 0 && + semakptr->u.sem_nsems < nsems) { DPRINTF(("too small\n")); error = EINVAL; goto error; @@ -431,10 +448,16 @@ sys_semget(struct proc *p, void *v, register_t *retval) error = EEXIST; goto error; } - if (semaptr_new != NULL) { - free(semaptr_new->sem_base, M_SEM); - pool_put(&sema_pool, semaptr_new); +#ifdef MAC + error = mac_sysvsem_check_semget(cred, + semakptr); + if (error) + goto error; + if (semakptr_new != NULL) { + free(semakptr_new->u.sem_base, M_SEM); + pool_put(&sema_pool, semakptr_new); } +#endif goto found; } } @@ -443,7 +466,7 @@ sys_semget(struct proc *p, void *v, register_t *retval) DPRINTF(("need to allocate the semid_ds\n")); if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) { for (semid = 0; semid < seminfo.semmni; semid++) { - if ((semaptr = sema[semid]) == NULL) + if ((semakptr = sema[semid]) == NULL) break; } if (semid == seminfo.semmni) { @@ -452,31 +475,35 @@ sys_semget(struct proc *p, void *v, register_t *retval) goto error; } DPRINTF(("semid %d is available\n", semid)); - semaptr_new->sem_perm.key = key; - semaptr_new->sem_perm.cuid = cred->cr_uid; - semaptr_new->sem_perm.uid = cred->cr_uid; - semaptr_new->sem_perm.cgid = cred->cr_gid; - semaptr_new->sem_perm.gid = cred->cr_gid; - semaptr_new->sem_perm.mode = (semflg & 0777); - semaptr_new->sem_perm.seq = semseqs[semid] = + semakptr_new->u.sem_perm.key = key; + semakptr_new->u.sem_perm.cuid = cred->cr_uid; + semakptr_new->u.sem_perm.uid = cred->cr_uid; + semakptr_new->u.sem_perm.cgid = cred->cr_gid; + semakptr_new->u.sem_perm.gid = cred->cr_gid; + semakptr_new->u.sem_perm.mode = (semflg & 0777); + semakptr_new->u.sem_perm.seq = semseqs[semid] = (semseqs[semid] + 1) & 0x7fff; - semaptr_new->sem_nsems = nsems; - semaptr_new->sem_otime = 0; - semaptr_new->sem_ctime = time_second; - sema[semid] = semaptr_new; + semakptr_new->u.sem_nsems = nsems; + semakptr_new->u.sem_otime = 0; + semakptr_new->u.sem_ctime = time_second; + sema[semid] = semakptr_new; semtot += nsems; +#ifdef MAC + mac_sysvsem_init(semakptr_new); + mac_sysvsem_create(cred, semakptr_new); +#endif } else { DPRINTF(("didn't find it and wasn't asked to create it\n")); return (ENOENT); } found: - *retval = IXSEQ_TO_IPCID(semid, sema[semid]->sem_perm); + *retval = IXSEQ_TO_IPCID(semid, sema[semid]->u.sem_perm); return (0); error: - if (semaptr_new != NULL) { - free(semaptr_new->sem_base, M_SEM); - pool_put(&sema_pool, semaptr_new); + if (semakptr_new != NULL) { + free(semakptr_new->u.sem_base, M_SEM); + pool_put(&sema_pool, semakptr_new); } return (error); } @@ -494,7 +521,7 @@ sys_semop(struct proc *p, void *v, register_t *retval) int semid = SCARG(uap, semid); size_t nsops = SCARG(uap, nsops); struct sembuf *sops; - struct semid_ds *semaptr; + struct semid_kernel *semakptr; struct sembuf *sopptr = NULL; struct sem *semptr = NULL; struct sem_undo *suptr = NULL; @@ -510,11 +537,11 @@ sys_semop(struct proc *p, void *v, register_t *retval) if (semid < 0 || semid >= seminfo.semmni) return (EINVAL); - if ((semaptr = sema[semid]) == NULL || - semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) + if ((semakptr = sema[semid]) == NULL || + semakptr->u.sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) return (EINVAL); - if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) { + if ((error = ipcperm(cred, &semakptr->u.sem_perm, IPC_W))) { DPRINTF(("error = %d from ipaccess\n", error)); return (error); } @@ -528,6 +555,12 @@ sys_semop(struct proc *p, void *v, register_t *retval) return (E2BIG); } +#ifdef MAC + error = mac_sysvsem_check_semop(cred, semakptr, IPC_W); + if (error) + return (error); +#endif + if (nsops <= NSOPS) sops = sopbuf; else @@ -556,15 +589,16 @@ sys_semop(struct proc *p, void *v, register_t *retval) for (i = 0; i < nsops; i++) { sopptr = &sops[i]; - if (sopptr->sem_num >= semaptr->sem_nsems) { + if (sopptr->sem_num >= semakptr->u.sem_nsems) { error = EFBIG; goto done2; } - semptr = &semaptr->sem_base[sopptr->sem_num]; + semptr = &semakptr->u.sem_base[sopptr->sem_num]; - DPRINTF(("semop: semaptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n", - semaptr, semaptr->sem_base, semptr, + DPRINTF(("semop: semakptr=%x, sem_base=%x, " + "semptr=%x, sem[%d]=%d : op=%d, flag=%s\n", + semakptr, semakptr->u.sem_base, semptr, sopptr->sem_num, semptr->semval, sopptr->sem_op, (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait")); @@ -606,7 +640,7 @@ sys_semop(struct proc *p, void *v, register_t *retval) */ DPRINTF(("semop: rollback 0 through %d\n", i - 1)); for (j = 0; j < i; j++) - semaptr->sem_base[sops[j].sem_num].semval -= + semakptr->u.sem_base[sops[j].sem_num].semval -= sops[j].sem_op; /* @@ -634,7 +668,8 @@ sys_semop(struct proc *p, void *v, register_t *retval) * Make sure that the semaphore still exists */ if (sema[semid] == NULL || - semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) { + semakptr->u.sem_perm.seq != + IPCID_TO_SEQ(SCARG(uap, semid))) { error = EIDRM; goto done2; } @@ -705,7 +740,7 @@ done: } for (j = 0; j < nsops; j++) - semaptr->sem_base[sops[j].sem_num].semval -= + semakptr->u.sem_base[sops[j].sem_num].semval -= sops[j].sem_op; DPRINTF(("error = %d from semundo_adjust\n", error)); @@ -716,11 +751,11 @@ done: /* We're definitely done - set the sempid's */ for (i = 0; i < nsops; i++) { sopptr = &sops[i]; - semptr = &semaptr->sem_base[sopptr->sem_num]; + semptr = &semakptr->u.sem_base[sopptr->sem_num]; semptr->sempid = p->p_p->ps_mainproc->p_pid; } - semaptr->sem_otime = time_second; + semakptr->u.sem_otime = time_second; /* Do a wakeup if any semaphore was up'd. */ if (do_wakeup) { @@ -777,24 +812,24 @@ semexit(struct process *pr) int semid = suptr->un_ent[ix].un_id; int semnum = suptr->un_ent[ix].un_num; int adjval = suptr->un_ent[ix].un_adjval; - struct semid_ds *semaptr; + struct semid_kernel *semakptr; - if ((semaptr = sema[semid]) == NULL) + if ((semakptr = sema[semid]) == NULL) panic("semexit - semid not allocated"); - if (semnum >= semaptr->sem_nsems) + if (semnum >= semakptr->u.sem_nsems) panic("semexit - semnum out of range"); DPRINTF(("semexit: %p id=%d num=%d(adj=%d) ; sem=%d\n", suptr->un_proc, suptr->un_ent[ix].un_id, suptr->un_ent[ix].un_num, suptr->un_ent[ix].un_adjval, - semaptr->sem_base[semnum].semval)); + semakptr->u.sem_base[semnum].semval)); if (adjval < 0 && - semaptr->sem_base[semnum].semval < -adjval) - semaptr->sem_base[semnum].semval = 0; + semakptr->u.sem_base[semnum].semval < -adjval) + semakptr->u.sem_base[semnum].semval = 0; else - semaptr->sem_base[semnum].semval += adjval; + semakptr->u.sem_base[semnum].semval += adjval; wakeup(&sema[semid]); DPRINTF(("semexit: back from wakeup\n")); @@ -818,7 +853,7 @@ sysctl_sysvsem(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { int error, val; - struct semid_ds **sema_new; + struct semid_kernel **sema_new; unsigned short *newseqs; if (namelen != 2) { @@ -849,10 +884,10 @@ sysctl_sysvsem(int *name, u_int namelen, void *oldp, size_t *oldlenp, return (EINVAL); /* Expand semsegs and semseqs arrays */ - sema_new = malloc(val * sizeof(struct semid_ds *), + sema_new = malloc(val * sizeof(struct semid_kernel *), M_SEM, M_WAITOK|M_ZERO); bcopy(sema, sema_new, - seminfo.semmni * sizeof(struct semid_ds *)); + seminfo.semmni * sizeof(struct semid_kernel *)); newseqs = malloc(val * sizeof(unsigned short), M_SEM, M_WAITOK|M_ZERO); bcopy(semseqs, newseqs, diff --git a/sys/kern/sysv_shm.c b/sys/kern/sysv_shm.c index 52351d1..5da4c96 100644 --- a/sys/kern/sysv_shm.c +++ b/sys/kern/sysv_shm.c @@ -68,12 +68,16 @@ #include +#ifdef MAC +#include +#endif + extern struct shminfo shminfo; -struct shmid_ds **shmsegs; /* linear mapping of shmid -> shmseg */ +struct shmid_kernel **shmsegs; /* linear mapping of shmid -> shmseg */ struct pool shm_pool; unsigned short *shmseqs; /* array of shm sequence numbers */ -struct shmid_ds *shm_find_segment_by_shmid(int); +struct shmid_kernel *shm_find_segment_by_shmid(int); /* * Provides the following externally accessible functions: @@ -84,7 +88,7 @@ struct shmid_ds *shm_find_segment_by_shmid(int); * shmsys(arg1, arg2, arg3, arg4); shm{at,ctl,dt,get}(arg2, arg3, arg4) * * Structures: - * shmsegs (an array of 'struct shmid_ds *') + * shmsegs (an array of 'struct shmid_kernel *') * per proc 'struct shmmap_head' with an array of 'struct shmmap_state' */ @@ -108,7 +112,7 @@ struct shmmap_head { }; int shm_find_segment_by_key(key_t); -void shm_deallocate_segment(struct shmid_ds *); +void shm_deallocate_segment(struct shmid_kernel *); int shm_delete_mapping(struct vmspace *, struct shmmap_state *); int shmget_existing(struct proc *, struct sys_shmget_args *, int, int, register_t *); @@ -118,41 +122,47 @@ int shmget_allocate_segment(struct proc *, struct sys_shmget_args *, int shm_find_segment_by_key(key_t key) { - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; int i; for (i = 0; i < shminfo.shmmni; i++) { shmseg = shmsegs[i]; - if (shmseg != NULL && shmseg->shm_perm.key == key) + if (shmseg != NULL && shmseg->u.shm_perm.key == key) return (i); } return (-1); } -struct shmid_ds * +struct shmid_kernel * shm_find_segment_by_shmid(int shmid) { int segnum; - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; segnum = IPCID_TO_IX(shmid); if (segnum < 0 || segnum >= shminfo.shmmni || (shmseg = shmsegs[segnum]) == NULL || - shmseg->shm_perm.seq != IPCID_TO_SEQ(shmid)) + shmseg->u.shm_perm.seq != IPCID_TO_SEQ(shmid)) return (NULL); - if ((shmseg->shm_perm.mode & (SHMSEG_REMOVED|SHMSEG_RMLINGER)) == SHMSEG_REMOVED) + if ((shmseg->u.shm_perm.mode & (SHMSEG_REMOVED|SHMSEG_RMLINGER)) == + SHMSEG_REMOVED) return (NULL); return (shmseg); } void -shm_deallocate_segment(struct shmid_ds *shmseg) +shm_deallocate_segment(struct shmid_kernel *shmseg) { struct shm_handle *shm_handle; size_t size; - shm_handle = shmseg->shm_internal; - size = round_page(shmseg->shm_segsz); +#ifdef MAC + mac_sysvshm_cleanup(shmseg); + mac_sysvshm_destroy(shmseg); +#endif + + shm_handle = shmseg->u.shm_internal; + size = round_page(shmseg->u.shm_segsz); uao_detach(shm_handle->shm_object); pool_put(&shm_pool, shmseg); shm_committed -= atop(size); @@ -162,7 +172,7 @@ shm_deallocate_segment(struct shmid_ds *shmseg) int shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s) { - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; int segnum; size_t size; @@ -170,12 +180,12 @@ shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s) if (segnum < 0 || segnum >= shminfo.shmmni || (shmseg = shmsegs[segnum]) == NULL) return (EINVAL); - size = round_page(shmseg->shm_segsz); + size = round_page(shmseg->u.shm_segsz); uvm_deallocate(&vm->vm_map, shmmap_s->va, size); shmmap_s->shmid = -1; - shmseg->shm_dtime = time_second; - if ((--shmseg->shm_nattch <= 0) && - (shmseg->shm_perm.mode & SHMSEG_REMOVED)) { + shmseg->u.shm_dtime = time_second; + if ((--shmseg->u.shm_nattch <= 0) && + (shmseg->u.shm_perm.mode & SHMSEG_REMOVED)) { shm_deallocate_segment(shmseg); shm_last_free = segnum; shmsegs[shm_last_free] = NULL; @@ -191,6 +201,10 @@ sys_shmdt(struct proc *p, void *v, register_t *retval) } */ *uap = v; struct shmmap_head *shmmap_h; struct shmmap_state *shmmap_s; +#ifdef MAC + struct shmid_kernel *shmsegptr; + int error; +#endif int i; shmmap_h = (struct shmmap_head *)p->p_vmspace->vm_shm; @@ -204,6 +218,13 @@ sys_shmdt(struct proc *p, void *v, register_t *retval) break; if (i == shmmap_h->shmseg) return (EINVAL); + +#ifdef MAC + shmsegptr = shmsegs[IPCID_TO_IX(shmmap_s->shmid)]; + error = mac_sysvshm_check_shmdt(p->p_ucred, shmsegptr); + return (error); +#endif + return (shm_delete_mapping(p->p_vmspace, shmmap_s)); } @@ -217,7 +238,7 @@ sys_shmat(struct proc *p, void *v, register_t *retval) } */ *uap = v; int error, i, flags; struct ucred *cred = p->p_ucred; - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; struct shmmap_head *shmmap_h; struct shmmap_state *shmmap_s; struct shm_handle *shm_handle; @@ -239,10 +260,15 @@ sys_shmat(struct proc *p, void *v, register_t *retval) shmseg = shm_find_segment_by_shmid(SCARG(uap, shmid)); if (shmseg == NULL) return (EINVAL); - error = ipcperm(cred, &shmseg->shm_perm, + error = ipcperm(cred, &shmseg->u.shm_perm, (SCARG(uap, shmflg) & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W); if (error) return (error); +#ifdef MAC + error = mac_sysvshm_check_shmat(cred, shmseg, SCARG(uap, shmflg)); + if (error) + return (error); +#endif for (i = 0, shmmap_s = shmmap_h->state; i < shmmap_h->shmseg; i++) { if (shmmap_s->shmid == -1) break; @@ -250,7 +276,7 @@ sys_shmat(struct proc *p, void *v, register_t *retval) } if (i >= shmmap_h->shmseg) return (EMFILE); - size = round_page(shmseg->shm_segsz); + size = round_page(shmseg->u.shm_segsz); prot = VM_PROT_READ; if ((SCARG(uap, shmflg) & SHM_RDONLY) == 0) prot |= VM_PROT_WRITE; @@ -268,7 +294,7 @@ sys_shmat(struct proc *p, void *v, register_t *retval) /* This is just a hint to uvm_map() about where to put it. */ attach_va = uvm_map_hint(p, prot); } - shm_handle = shmseg->shm_internal; + shm_handle = shmseg->u.shm_internal; uao_reference(shm_handle->shm_object); error = uvm_map(&p->p_vmspace->vm_map, &attach_va, size, shm_handle->shm_object, 0, 0, UVM_MAPFLAG(prot, prot, @@ -280,9 +306,9 @@ sys_shmat(struct proc *p, void *v, register_t *retval) shmmap_s->va = attach_va; shmmap_s->shmid = SCARG(uap, shmid); - shmseg->shm_lpid = p->p_p->ps_mainproc->p_pid; - shmseg->shm_atime = time_second; - shmseg->shm_nattch++; + shmseg->u.shm_lpid = p->p_p->ps_mainproc->p_pid; + shmseg->u.shm_atime = time_second; + shmseg->u.shm_nattch++; *retval = attach_va; return (0); } @@ -306,39 +332,45 @@ shmctl1(struct proc *p, int shmid, int cmd, caddr_t buf, int (*ds_copyout)(const void *, void *, size_t)) { struct ucred *cred = p->p_ucred; - struct shmid_ds inbuf, *shmseg; + struct shmid_ds inbuf; + struct shmid_kernel *shmseg; int error; shmseg = shm_find_segment_by_shmid(shmid); if (shmseg == NULL) return (EINVAL); +#ifdef MAC + error = mac_sysvshm_check_shmctl(cred, shmseg, cmd); + if (error) + return (error); +#endif switch (cmd) { case IPC_STAT: - if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_R)) != 0) + if ((error = ipcperm(cred, &shmseg->u.shm_perm, IPC_R)) != 0) return (error); - error = ds_copyout(shmseg, buf, sizeof(inbuf)); + error = ds_copyout(&shmseg->u, buf, sizeof(inbuf)); if (error) return (error); break; case IPC_SET: - if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0) + if ((error = ipcperm(cred, &shmseg->u.shm_perm, IPC_M)) != 0) return (error); error = ds_copyin(buf, &inbuf, sizeof(inbuf)); if (error) return (error); - shmseg->shm_perm.uid = inbuf.shm_perm.uid; - shmseg->shm_perm.gid = inbuf.shm_perm.gid; - shmseg->shm_perm.mode = - (shmseg->shm_perm.mode & ~ACCESSPERMS) | + shmseg->u.shm_perm.uid = inbuf.shm_perm.uid; + shmseg->u.shm_perm.gid = inbuf.shm_perm.gid; + shmseg->u.shm_perm.mode = + (shmseg->u.shm_perm.mode & ~ACCESSPERMS) | (inbuf.shm_perm.mode & ACCESSPERMS); - shmseg->shm_ctime = time_second; + shmseg->u.shm_ctime = time_second; break; case IPC_RMID: - if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0) + if ((error = ipcperm(cred, &shmseg->u.shm_perm, IPC_M)) != 0) return (error); - shmseg->shm_perm.key = IPC_PRIVATE; - shmseg->shm_perm.mode |= SHMSEG_REMOVED; - if (shmseg->shm_nattch <= 0) { + shmseg->u.shm_perm.key = IPC_PRIVATE; + shmseg->u.shm_perm.mode |= SHMSEG_REMOVED; + if (shmseg->u.shm_nattch <= 0) { shm_deallocate_segment(shmseg); shm_last_free = IPCID_TO_IX(shmid); shmsegs[shm_last_free] = NULL; @@ -361,19 +393,24 @@ shmget_existing(struct proc *p, } */ *uap, int mode, int segnum, register_t *retval) { - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; struct ucred *cred = p->p_ucred; int error; shmseg = shmsegs[segnum]; /* We assume the segnum is valid */ - if ((error = ipcperm(cred, &shmseg->shm_perm, mode)) != 0) + if ((error = ipcperm(cred, &shmseg->u.shm_perm, mode)) != 0) return (error); - if (SCARG(uap, size) && SCARG(uap, size) > shmseg->shm_segsz) + if (SCARG(uap, size) && SCARG(uap, size) > shmseg->u.shm_segsz) return (EINVAL); if ((SCARG(uap, shmflg) & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL)) return (EEXIST); - *retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); +#ifdef MAC + error = mac_sysvshm_check_shmget(cred, shmseg, SCARG(uap, shmflg)); + if (error) + return (error); +#endif + *retval = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm); return (0); } @@ -390,7 +427,7 @@ shmget_allocate_segment(struct proc *p, key_t key; int segnum; struct ucred *cred = p->p_ucred; - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; struct shm_handle *shm_handle; int error = 0; @@ -439,19 +476,23 @@ shmget_allocate_segment(struct proc *p, shm_handle = (struct shm_handle *)((caddr_t)shmseg + sizeof(*shmseg)); shm_handle->shm_object = uao_create(size, 0); - shmseg->shm_perm.cuid = shmseg->shm_perm.uid = cred->cr_uid; - shmseg->shm_perm.cgid = shmseg->shm_perm.gid = cred->cr_gid; - shmseg->shm_perm.mode = (mode & (ACCESSPERMS|SHMSEG_RMLINGER)); - shmseg->shm_perm.seq = shmseqs[segnum] = (shmseqs[segnum] + 1) & 0x7fff; - shmseg->shm_perm.key = key; - shmseg->shm_segsz = SCARG(uap, size); - shmseg->shm_cpid = p->p_p->ps_mainproc->p_pid; - shmseg->shm_lpid = shmseg->shm_nattch = 0; - shmseg->shm_atime = shmseg->shm_dtime = 0; - shmseg->shm_ctime = time_second; - shmseg->shm_internal = shm_handle; - - *retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); + shmseg->u.shm_perm.cuid = shmseg->u.shm_perm.uid = cred->cr_uid; + shmseg->u.shm_perm.cgid = shmseg->u.shm_perm.gid = cred->cr_gid; + shmseg->u.shm_perm.mode = (mode & (ACCESSPERMS|SHMSEG_RMLINGER)); + shmseg->u.shm_perm.seq = shmseqs[segnum] = + (shmseqs[segnum] + 1) & 0x7fff; + shmseg->u.shm_perm.key = key; + shmseg->u.shm_segsz = SCARG(uap, size); + shmseg->u.shm_cpid = p->p_p->ps_mainproc->p_pid; + shmseg->u.shm_lpid = shmseg->u.shm_nattch = 0; + shmseg->u.shm_atime = shmseg->u.shm_dtime = 0; + shmseg->u.shm_ctime = time_second; + shmseg->u.shm_internal = shm_handle; +#ifdef MAC + mac_sysvshm_init(shmseg); + mac_sysvshm_create(cred, shmseg); +#endif + *retval = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm); return (error); } @@ -488,7 +529,7 @@ shmfork(struct vmspace *vm1, struct vmspace *vm2) { struct shmmap_head *shmmap_h; struct shmmap_state *shmmap_s; - struct shmid_ds *shmseg; + struct shmid_kernel *shmseg; size_t size; int i; @@ -505,7 +546,7 @@ shmfork(struct vmspace *vm1, struct vmspace *vm2) i++, shmmap_s++) { if (shmmap_s->shmid != -1 && (shmseg = shmsegs[IPCID_TO_IX(shmmap_s->shmid)]) != NULL) - shmseg->shm_nattch++; + shmseg->u.shm_nattch++; } } @@ -530,15 +571,13 @@ shmexit(struct vmspace *vm) void shminit(void) { - - pool_init(&shm_pool, sizeof(struct shmid_ds) + + pool_init(&shm_pool, sizeof(struct shmid_kernel) + sizeof(struct shm_handle), 0, 0, 0, "shmpl", &pool_allocator_nointr); - shmsegs = malloc(shminfo.shmmni * sizeof(struct shmid_ds *), + shmsegs = malloc(shminfo.shmmni * sizeof(struct shmid_kernel *), M_SHM, M_WAITOK|M_ZERO); shmseqs = malloc(shminfo.shmmni * sizeof(unsigned short), M_SHM, M_WAITOK|M_ZERO); - shminfo.shmmax *= PAGE_SIZE; /* actually in pages */ shm_last_free = 0; shm_nused = 0; @@ -553,7 +592,7 @@ sysctl_sysvshm(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { int error, val; - struct shmid_ds **newsegs; + struct shmid_kernel **newsegs; unsigned short *newseqs; if (namelen != 2) { @@ -598,10 +637,10 @@ sysctl_sysvshm(int *name, u_int namelen, void *oldp, size_t *oldlenp, return (EINVAL); /* Expand shmsegs and shmseqs arrays */ - newsegs = malloc(val * sizeof(struct shmid_ds *), + newsegs = malloc(val * sizeof(struct shmid_kernel *), M_SHM, M_WAITOK|M_ZERO); bcopy(shmsegs, newsegs, - shminfo.shmmni * sizeof(struct shmid_ds *)); + shminfo.shmmni * sizeof(struct shmid_kernel *)); free(shmsegs, M_SHM); shmsegs = newsegs; newseqs = malloc(val * sizeof(unsigned short), M_SHM, diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c index 5564f9d..66b1824 100644 --- a/sys/kern/uipc_mbuf.c +++ b/sys/kern/uipc_mbuf.c @@ -92,6 +92,10 @@ #include +#ifdef MAC +#include +#endif + struct mbstat mbstat; /* mbuf stats */ struct pool mbpool; /* mbuf pool */ @@ -235,6 +239,15 @@ m_gethdr(int nowait, int type) m->m_pkthdr.pf.tag = 0; m->m_pkthdr.pf.flags = 0; m->m_pkthdr.pf.routed = 0; +#ifdef MAC + /* If the label init fails, fail the alloc */ + if (mac_mbuf_init(m, nowait)) { + pool_put(&mbpool, m); + splx(s); + return (NULL); + } +#endif + mbstat.m_mtypes[type]++; } return (m); } @@ -259,6 +272,10 @@ m_inithdr(struct mbuf *m) m->m_pkthdr.pf.tag = 0; m->m_pkthdr.pf.flags = 0; m->m_pkthdr.pf.routed = 0; +#ifdef MAC + if (mac_mbuf_init(m, M_NOWAIT)) + return (NULL); +#endif return (m); } diff --git a/sys/kern/uipc_mbuf2.c b/sys/kern/uipc_mbuf2.c index 806de72..f246f7a 100644 --- a/sys/kern/uipc_mbuf2.c +++ b/sys/kern/uipc_mbuf2.c @@ -68,6 +68,10 @@ #include #include +#ifdef MAC +#include +#endif + /* can't call it m_dup(), as freebsd[34] uses m_dup() with different arg */ static struct mbuf *m_dup1(struct mbuf *, int, int, int); @@ -283,6 +287,10 @@ void m_tag_delete(struct mbuf *m, struct m_tag *t) { SLIST_REMOVE(&m->m_pkthdr.tags, t, m_tag, m_tag_link); +#ifdef MAC + if (t->m_tag_id == PACKET_TAG_MACLABEL) + mac_mbuf_tag_destroy(t); +#endif free(t, M_PACKET_TAGS); } @@ -294,6 +302,10 @@ m_tag_delete_chain(struct mbuf *m) while ((p = SLIST_FIRST(&m->m_pkthdr.tags)) != NULL) { SLIST_REMOVE_HEAD(&m->m_pkthdr.tags, m_tag_link); +#ifdef MAC + if (p->m_tag_id == PACKET_TAG_MACLABEL) + mac_mbuf_tag_destroy(p); +#endif free(p, M_PACKET_TAGS); } } @@ -325,7 +337,21 @@ m_tag_copy(struct m_tag *t) p = m_tag_get(t->m_tag_id, t->m_tag_len, M_NOWAIT); if (p == NULL) return (NULL); - bcopy(t + 1, p + 1, t->m_tag_len); /* Copy the data */ +#ifdef MAC + /* + * XXXMAC: We should probably pass off the initialization, and + * copying here? Can we hide that PACKET_TAG_MACLABEL is special + * from the mbuf code? + */ + if (t->m_tag_id == PACKET_TAG_MACLABEL) { + if (mac_mbuf_tag_init(p, M_NOWAIT)) { + free(p, M_PACKET_TAGS); + return (NULL); + } + mac_mbuf_tag_copy(t, p); + } else +#endif + bcopy(t + 1, p + 1, t->m_tag_len); /* Copy the data */ return (p); } diff --git a/sys/kern/uipc_socket.c b/sys/kern/uipc_socket.c index 022ca85..3573082 100644 --- a/sys/kern/uipc_socket.c +++ b/sys/kern/uipc_socket.c @@ -1,4 +1,4 @@ -/* $OpenBSD: claudio $ */ +/* $OpenBSD: uipc_socket.c,v 1.66 2007/02/26 23:53:33 kurt Exp $ */ /* $NetBSD: uipc_socket.c,v 1.21 1996/02/04 02:17:52 christos Exp $ */ /* @@ -48,6 +48,11 @@ #include #include #include +#include + +#ifdef MAC +#include +#endif void filt_sordetach(struct knote *kn); int filt_soread(struct knote *kn, long hint); @@ -105,6 +110,13 @@ socreate(int dom, struct socket **aso, int type, int proto) return (EPROTOTYPE); s = splsoftnet(); so = pool_get(&socket_pool, PR_WAITOK | PR_ZERO); +#ifdef MAC + if ((error = mac_socket_init(so, M_WAITOK)) != 0) { + pool_put(&socket_pool, so); + splx(s); + return (error); + } +#endif TAILQ_INIT(&so->so_q0); TAILQ_INIT(&so->so_q); so->so_type = type; @@ -116,6 +128,9 @@ socreate(int dom, struct socket **aso, int type, int proto) so->so_egid = p->p_ucred->cr_gid; so->so_cpid = p->p_pid; so->so_proto = prp; +#ifdef MAC + mac_socket_create(p->p_ucred, so); +#endif error = (*prp->pr_usrreq)(so, PRU_ATTACH, NULL, (struct mbuf *)(long)proto, NULL, p); if (error) { @@ -191,6 +206,9 @@ sofree(struct socket *so) } sbrelease(&so->so_snd); sorflush(so); +#ifdef MAC + mac_socket_destroy(so); +#endif pool_put(&socket_pool, so); } @@ -671,6 +689,17 @@ dontblock: if (m->m_type != MT_SONAME) panic("receive 1a"); #endif +#ifdef MAC + splx(s); + error = mac_socket_check_soreceive(so, m); + s = splsoftnet(); + nextrecord = m->m_nextpkt; + + if (error != 0) { + sbdroprecord(&so->so_rcv); + goto release; + } +#endif orig_resid = 0; if (flags & MSG_PEEK) { if (paddr) @@ -1101,6 +1130,18 @@ sosetopt(struct socket *so, int level, int optname, struct mbuf *m0) break; } + case SO_LABEL: +#ifdef MAC + if (m == NULL || m->m_len < sizeof(struct mac)) { + error = EINVAL; + goto bad; + } + error = mac_setsockopt_label(curproc->p_ucred, so, + mtod(m, struct mac *)); /* XXX */ +#else + error = EOPNOTSUPP; +#endif + break; default: error = ENOPROTOOPT; break; @@ -1121,6 +1162,9 @@ int sogetopt(struct socket *so, int level, int optname, struct mbuf **mp) { struct mbuf *m; +#ifdef MAC + int error; +#endif if (level != SOL_SOCKET) { if (so->so_proto && so->so_proto->pr_ctloutput) { @@ -1192,7 +1236,34 @@ sogetopt(struct socket *so, int level, int optname, struct mbuf **mp) (val % hz) * tick; break; } - + case SO_LABEL: +#ifdef MAC + m->m_len = sizeof(struct mac); + error = mac_getsockopt_label(curproc->p_ucred, so, + mtod(m, struct mac *)); /* XXX */ + if (error) { + m_free(m); + return (error); + } + break; +#else + m_free(m); + return (EOPNOTSUPP); +#endif + case SO_PEERLABEL: +#ifdef MAC + m->m_len = sizeof(struct mac); + error = mac_getsockopt_peerlabel(curproc->p_ucred, so, + mtod(m, struct mac *)); /* XXX */ + if (error) { + m_free(m); + return (error); + } + break; +#else + m_free(m); + return (EOPNOTSUPP); +#endif default: (void)m_free(m); return (ENOPROTOOPT); diff --git a/sys/kern/uipc_socket2.c b/sys/kern/uipc_socket2.c index 6d93852..c8b8f3f 100644 --- a/sys/kern/uipc_socket2.c +++ b/sys/kern/uipc_socket2.c @@ -46,6 +46,10 @@ #include #include +#ifdef MAC +#include +#endif + /* * Primitive routines for operating on sockets and socket buffers */ @@ -165,6 +169,12 @@ sonewconn(struct socket *head, int connstatus) so = pool_get(&socket_pool, PR_NOWAIT|PR_ZERO); if (so == NULL) return ((struct socket *)0); +#ifdef MAC + if (mac_socket_init(so, M_NOWAIT) != 0) { + pool_put(&socket_pool, so); + return (NULL); + } +#endif so->so_type = head->so_type; so->so_options = head->so_options &~ SO_ACCEPTCONN; so->so_linger = head->so_linger; @@ -179,6 +189,9 @@ sonewconn(struct socket *head, int connstatus) so->so_cpid = head->so_cpid; so->so_siguid = head->so_siguid; so->so_sigeuid = head->so_sigeuid; +#ifdef MAC + mac_socket_newconn(head, so); +#endif /* * If we are tight on mbuf clusters, create the new socket diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c index 8b238d2..40d5a88 100644 --- a/sys/kern/uipc_syscalls.c +++ b/sys/kern/uipc_syscalls.c @@ -1,4 +1,4 @@ -/* $OpenBSD: otto $ */ +/* $OpenBSD: uipc_syscalls.c,v 1.66 2006/10/23 07:13:56 henning Exp $ */ /* $NetBSD: uipc_syscalls.c,v 1.19 1996/02/09 19:00:48 christos Exp $ */ /* @@ -54,6 +54,10 @@ #include #include +#ifdef MAC +#include +#endif + /* * System call interface to the socket abstraction. */ @@ -72,6 +76,13 @@ sys_socket(struct proc *p, void *v, register_t *retval) struct file *fp; int fd, error; +#ifdef MAC + error = mac_socket_check_create(p->p_ucred, SCARG(uap, domain), + SCARG(uap, type), SCARG(uap, protocol)); + if (error) + return (error); +#endif + fdplock(fdp); if ((error = falloc(p, &fp, &fd)) != 0) @@ -109,12 +120,20 @@ sys_bind(struct proc *p, void *v, register_t *retval) if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) return (error); +#ifdef MAC + error = mac_socket_check_bind(p->p_ucred, fp->f_data, SCARG(uap, name)); + if (error) + goto done; +#endif error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen), MT_SONAME); if (error == 0) { error = sobind(fp->f_data, nam, p); m_freem(nam); } +#ifdef MAC +done: +#endif FRELE(fp); return (error); } @@ -132,7 +151,15 @@ sys_listen(struct proc *p, void *v, register_t *retval) if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) return (error); +#ifdef MAC + error = mac_socket_check_listen(p->p_ucred, fp->f_data); + if (error) + goto done; +#endif error = solisten(fp->f_data, SCARG(uap, backlog)); +#ifdef MAC +done: +#endif FRELE(fp); return (error); } @@ -164,6 +191,11 @@ sys_accept(struct proc *p, void *v, register_t *retval) error = EINVAL; goto bad; } +#ifdef MAC + error = mac_socket_check_accept(p->p_ucred, head); + if (error != 0) + goto bad; +#endif if ((head->so_state & SS_NBIO) && head->so_qlen == 0) { if (head->so_state & SS_CANTRCVMORE) error = ECONNABORTED; @@ -227,6 +259,10 @@ sys_accept(struct proc *p, void *v, register_t *retval) fp->f_data = so; nam = m_get(M_WAIT, MT_SONAME); error = soaccept(so, nam); +#ifdef MAC + if (!error) + error = mac_socket_check_accepted(p->p_ucred, so, nam); +#endif if (!error && SCARG(uap, name)) { if (namelen > nam->m_len) namelen = nam->m_len; @@ -272,6 +308,11 @@ sys_connect(struct proc *p, void *v, register_t *retval) FRELE(fp); return (EALREADY); } +#ifdef MAC + error = mac_socket_check_connect(p->p_ucred, so, SCARG(uap, name)); + if (error) + goto bad; +#endif error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen), MT_SONAME); if (error) @@ -320,6 +361,13 @@ sys_socketpair(struct proc *p, void *v, register_t *retval) struct socket *so1, *so2; int fd, error, sv[2]; +#ifdef MAC + error = mac_socket_check_create(p->p_ucred, SCARG(uap, domain), + SCARG(uap, type), SCARG(uap, protocol)); + if (error) + return (error); +#endif + error = socreate(SCARG(uap, domain), &so1, SCARG(uap, type), SCARG(uap, protocol)); if (error) @@ -460,6 +508,13 @@ sendit(struct proc *p, int s, struct msghdr *mp, int flags, register_t *retsize) if ((error = getsock(p->p_fd, s, &fp)) != 0) return (error); + +#ifdef MAC + error = mac_socket_check_send(p->p_ucred, fp->f_data); + if (error) + goto bad; +#endif + auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; @@ -639,6 +694,11 @@ recvit(struct proc *p, int s, struct msghdr *mp, caddr_t namelenp, if ((error = getsock(p->p_fd, s, &fp)) != 0) return (error); +#ifdef MAC + error = mac_socket_check_receive(p->p_ucred, fp->f_data); + if (error) + goto out; +#endif auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c index 8749271..3548658 100644 --- a/sys/kern/uipc_usrreq.c +++ b/sys/kern/uipc_usrreq.c @@ -47,6 +47,9 @@ #include #include #include +#include + +#include /* * Unix communications domain. @@ -413,6 +416,10 @@ unp_bind(struct unpcb *unp, struct mbuf *nam, struct proc *p) return (error); vp = nd.ni_vp; if (vp != NULL) { +#ifdef MAC + error = EADDRINUSE; + goto abort; +#else VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); if (nd.ni_dvp == vp) vrele(nd.ni_dvp); @@ -420,10 +427,23 @@ unp_bind(struct unpcb *unp, struct mbuf *nam, struct proc *p) vput(nd.ni_dvp); vrele(vp); return (EADDRINUSE); +#endif /* MAC */ } VATTR_NULL(&vattr); vattr.va_type = VSOCK; vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask; +#ifdef MAC + error = mac_vnode_check_create(p->p_ucred, nd.ni_dvp, &nd.ni_cnd, + &vattr); + if (error) + goto abort; + VOP_UNLOCK(nd.ni_dvp, 0, p); + error = relookup(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd); + if (error == 0 && nd.ni_vp) + error = EADDRINUSE; + if (error) + goto abort; +#endif /* MAC */ error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); if (error) return (error); @@ -436,6 +456,17 @@ unp_bind(struct unpcb *unp, struct mbuf *nam, struct proc *p) unp->unp_flags |= UNP_FEIDSBIND; VOP_UNLOCK(vp, 0, p); return (0); +#ifdef MAC +abort: + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + if (nd.ni_dvp == nd.ni_vp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + if (nd.ni_vp) + vrele(nd.ni_vp); + return (error); +#endif /* MAC */ } int @@ -448,7 +479,12 @@ unp_connect(struct socket *so, struct mbuf *nam, struct proc *p) int error; struct nameidata nd; +#ifdef ANOUBIS + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | SAVENAME | WANTPARENT, + UIO_SYSSPACE, soun->sun_path, p); +#else NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, soun->sun_path, p); +#endif if (nam->m_data + nam->m_len == &nam->m_dat[MLEN]) { /* XXX */ if (*(mtod(nam, caddr_t) + nam->m_len - 1) != 0) return (EMSGSIZE); @@ -459,8 +495,24 @@ unp_connect(struct socket *so, struct mbuf *nam, struct proc *p) vp = nd.ni_vp; if (vp->v_type != VSOCK) { error = ENOTSOCK; +#ifdef ANOUBIS + vrele(nd.ni_dvp); + pool_put(&namei_pool, nd.ni_cnd.cn_pnbuf); +#endif goto bad; } +#ifdef MAC +#ifdef ANOUBIS + error = mac_vnode_check_open(p->p_ucred, vp, VWRITE | VREAD, + nd.ni_dvp, &nd.ni_cnd); + vrele(nd.ni_dvp); + pool_put(&namei_pool, nd.ni_cnd.cn_pnbuf); +#else + error = mac_vnode_check_open(p->p_ucred, vp, VWRITE | VREAD); +#endif + if (error) + goto bad; +#endif if ((error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) != 0) goto bad; so2 = vp->v_socket; @@ -493,6 +545,11 @@ unp_connect(struct socket *so, struct mbuf *nam, struct proc *p) unp->unp_connid.unp_egid = unp2->unp_connid.unp_egid; unp->unp_flags |= UNP_FEIDS; } +#ifdef MAC + mac_socketpeer_set_from_socket(so, so3); + mac_socketpeer_set_from_socket(so3, so); +#endif + } error = unp_connect2(so, so2); bad: diff --git a/sys/kern/vfs_acl.c b/sys/kern/vfs_acl.c new file mode 100644 index 0000000..b8376d5 --- /dev/null +++ b/sys/kern/vfs_acl.c @@ -0,0 +1,448 @@ +/* + * Copyright (c) 1999-2006 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: vfs_acl.c,v 1.56 2008/01/13 14:44:09 attilio Exp $ + */ + +/* + * ACL system calls and other functions common across different ACL types. + * Type-specific routines go into subr_.c. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef MAC +#include +#endif + +struct pool aclpool; + +int vn_acl_set(struct proc *, struct vnode *, acl_type_t, struct acl *); +int vn_acl_get(struct proc *, struct vnode *, acl_type_t, struct acl *); +int vn_acl_del(struct proc *, struct vnode *, acl_type_t); +int vn_acl_check(struct proc *, struct vnode *, acl_type_t, struct acl *); + +/* + * These calls wrap the real vnode operations, and are called by the syscall + * code once the syscall has converted the path or file descriptor to a vnode + * (unlocked). The aclp pointer is assumed still to point to userland, so + * this should not be consumed within the kernel except by syscall code. + * Other code should directly invoke VOP_{SET,GET}ACL. + */ + +/* + * Given a vnode, set its ACL. The vnode is expected to have been referenced by + * the caller (so it is locked and vput()'d in the end of this function). + */ +int +vn_acl_set(struct proc *p, struct vnode *vp, acl_type_t type, struct acl *aclp) +{ + struct acl inkernacl; + int error; + + error = copyin(aclp, &inkernacl, sizeof(struct acl)); + if (error) + return(error); + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setacl(p->p_ucred, vp, type, &inkernacl); + if (error) { + vput(vp); + return (error); + } +#endif + + error = VOP_SETACL(vp, type, &inkernacl, p->p_ucred, p); + + vput(vp); + + return (error); +} + +/* + * Given a vnode, get its ACL. The vnode is expected to have been referenced by + * the caller (so it is locked and vput()'d in the end of this function). + */ +int +vn_acl_get(struct proc *p, struct vnode *vp, acl_type_t type, struct acl *aclp) +{ + struct acl inkernelacl; + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_getacl(p->p_ucred, vp, type); + if (error) { + vput(vp); + return (error); + } +#endif + + error = VOP_GETACL(vp, type, &inkernelacl, p->p_ucred, p); + + vput(vp); + + if (!error) + error = copyout(&inkernelacl, aclp, sizeof(struct acl)); + + return (error); +} + +/* + * Given a vnode, delete its ACL. The vnode is expected to have been referenced + * by the caller (so it is locked and vput()'d in the end of this function). + */ +int +vn_acl_del(struct proc *p, struct vnode *vp, acl_type_t type) +{ + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_deleteacl(p->p_ucred, vp, type); + if (error) { + vput(vp); + return (error); + } +#endif + + error = VOP_SETACL(vp, type, 0, p->p_ucred, p); + + vput(vp); + + return (error); +} + +/* + * Given a vnode, check whether an ACL is appropriate for it. The vnode is + * expected to have been referenced by the caller (so it is vrele()'d in the + * end of this function). + */ +int +vn_acl_check(struct proc *p, struct vnode *vp, acl_type_t type, + struct acl *aclp) +{ + struct acl inkernelacl; + int error; + + error = copyin(aclp, &inkernelacl, sizeof(struct acl)); + if (error) { + vrele(vp); + return (error); + } + + error = VOP_ACLCHECK(vp, type, &inkernelacl, p->p_ucred, p); + + vrele(vp); + + return (error); +} + +/* + * syscalls -- convert the path/fd to a vnode, and call vn_acl_whatever. Don't + * need to lock, as the vn_acl_* code will get/release any locks required. + */ + +/* + * Given a file path, get an ACL for it. + */ +int +sys___acl_get_file(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_get_file_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_get(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file path, get an ACL for it; don't follow links. + */ +int +sys___acl_get_link(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_get_link_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_get(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file path, set an ACL for it. + */ +int +sys___acl_set_file(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_set_file_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_set(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file path, set an ACL for it; don't follow links. + */ +int +sys___acl_set_link(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_set_link_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_set(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file descriptor, get an ACL for it. + */ +int +sys___acl_get_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_get_fd_args *uap = v; + struct vnode *vp; + struct file *fp; + int error; + + error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + if (error) + return (error); + + vp = (struct vnode *)fp->f_data; + vref(vp); /* vn_acl_get() will drop the reference. */ + + error = vn_acl_get(p, vp, SCARG(uap, type), SCARG(uap, aclp)); + + FRELE(fp); + + return (error); +} + +/* + * Given a file descriptor, set an ACL for it. + */ +int +sys___acl_set_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_set_fd_args *uap = v; + struct vnode *vp; + struct file *fp; + int error; + + error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + if (error) + return (error); + + vp = (struct vnode *)fp->f_data; + vref(vp); /* vn_acl_set() will drop the reference. */ + + error = vn_acl_set(p, vp, SCARG(uap, type), SCARG(uap, aclp)); + + FRELE(fp); + + return (error); +} + +/* + * Given a file path, delete an ACL from it. + */ +int +sys___acl_delete_file(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_delete_file_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_del(p, nd.ni_vp, SCARG(uap, type))); +} + +/* + * Given a file path, delete an ACL from it; don't follow links. + */ +int +sys___acl_delete_link(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_delete_link_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_del(p, nd.ni_vp, SCARG(uap, type))); +} + +/* + * Given a file path, delete an ACL from it. + */ +int +sys___acl_delete_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_delete_fd_args *uap = v; + struct vnode *vp; + struct file *fp; + int error; + + error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + if (error) + return (error); + + vp = (struct vnode *)fp->f_data; + vref(vp); /* vn_acl_del() will drop the reference. */ + + error = vn_acl_del(p, vp, SCARG(uap, type)); + + FRELE(fp); + + return (error); +} + +/* + * Given a file path, check an ACL for it. + */ +int +sys___acl_aclcheck_file(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_aclcheck_file_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_check(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file path, check an ACL for it; don't follow links. + */ +int +sys___acl_aclcheck_link(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_aclcheck_link_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + + error = namei(&nd); + if (error) + return (error); + + return (vn_acl_check(p, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp))); +} + +/* + * Given a file descriptor, check an ACL for it. + */ +int +sys___acl_aclcheck_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys___acl_aclcheck_fd_args *uap = v; + struct vnode *vp; + struct file *fp; + int error; + + error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + if (error) + return (error); + + vp = (struct vnode *)fp->f_data; + vref(vp); /* vn_acl_check() will drop the reference. */ + + error = vn_acl_check(p, vp, SCARG(uap, type), SCARG(uap, aclp)); + + FRELE(fp); + + return (error); +} + +void +acl_init(void) +{ + pool_init(&aclpool, sizeof(struct acl), 0, 0, 0, "aclpl", + &pool_allocator_nointr); +} diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c new file mode 100644 index 0000000..86b323f --- /dev/null +++ b/sys/kern/vfs_extattr.c @@ -0,0 +1,726 @@ +/* + * Copyright (c) 1999-2001 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: vfs_extattr.c,v 1.431 2006/12/23 00:30:03 rwatson Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef MAC +#include +#endif + +int extattr_set_vp(struct vnode *, int, const char *, void *, size_t, + struct proc *, register_t *); +int extattr_get_vp(struct vnode *, int, const char *, void *, size_t, + struct proc *, register_t *); +int extattr_delete_vp(struct vnode *, int, const char *, struct proc *); +int extattr_list_vp(struct vnode *, int, void *, size_t, struct proc *, + register_t *); + +/* + * Syscall to push extended attribute configuration information into the VFS. + * Accepts a path, which it converts to a mountpoint, as well as a command + * (int cmd), and attribute name and misc data. + * + * Currently this is used only by UFS1 extended attributes. + */ +int +sys_extattrctl(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattrctl_args *uap = v; + struct vnode *filename_vp; + struct nameidata nd; + struct mount *mp; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + /* + * uap->attrname is not always defined. We check again later when we + * invoke the VFS call so as to pass in NULL there if needed. + */ + if (SCARG(uap, attrname) != NULL) { + error = copyinstr(SCARG(uap, attrname), attrname, + EXTATTR_MAXNAMELEN, NULL); + if (error) + return (error); + } + + /* + * uap->filename is not always defined. If it is, grab a vnode lock, + * which VFS_EXTATTRCTL() will later release. + */ + filename_vp = NULL; + if (SCARG(uap, filename) != NULL) { + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, + SCARG(uap, filename), p); + error = namei(&nd); + if (error) + return (error); + filename_vp = nd.ni_vp; + } + + /* uap->path is always defined. */ + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) { + if (filename_vp != NULL) + vput(filename_vp); + goto out; + } + mp = nd.ni_vp->v_mount; + + error = VFS_EXTATTRCTL(mp, SCARG(uap, cmd), filename_vp, + SCARG(uap, attrnamespace), + SCARG(uap, attrname) != NULL ? attrname : NULL, p); + + /* + * VFS_EXTATTRCTL will have unlocked, but not de-ref'd, filename_vp, + * so vrele it if it is defined. + */ + if (filename_vp != NULL) + vrele(filename_vp); +out: + return (error); +} + +/*- + * Set a named extended attribute on a file or directory + * + * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", + * kernelspace string pointer "attrname", userspace buffer + * pointer "data", buffer length "nbytes", proc "p". + * Returns: 0 on success, an error number otherwise + * Locks: none + * References: vp must be a valid reference for the duration of the call + */ +int +extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, + void *data, size_t nbytes, struct proc *p, register_t *retval) +{ + struct uio auio; + struct iovec aiov; + ssize_t cnt; + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + aiov.iov_base = data; + aiov.iov_len = nbytes; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_offset = 0; + if (nbytes > INT_MAX) { + error = EINVAL; + goto done; + } + auio.uio_resid = nbytes; + auio.uio_rw = UIO_WRITE; + auio.uio_segflg = UIO_USERSPACE; + auio.uio_procp = p; + cnt = nbytes; + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setextattr(p->p_ucred, vp, attrnamespace, + attrname, &auio); + if (error) + goto done; +#endif + + error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, + p->p_ucred, p); + cnt -= auio.uio_resid; + *retval = cnt; + +done: + VOP_UNLOCK(vp, 0, p); + return (error); +} + +int +sys_extattr_set_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_set_fd_args *uap = v; + struct file *fp; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + error = getvnode(p->p_fd, SCARG(uap, fd), &fp); + if (error) + return (error); + + error = extattr_set_vp((struct vnode *)fp->f_data, + SCARG(uap, attrnamespace), attrname, SCARG(uap, data), + SCARG(uap, nbytes), p, retval); + FRELE(fp); + + return (error); +} + +int +sys_extattr_set_file(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_set_file_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_set_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +int +sys_extattr_set_link(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_set_link_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_set_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +/*- + * Get a named extended attribute on a file or directory + * + * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", + * kernelspace string pointer "attrname", userspace buffer + * pointer "data", buffer length "nbytes", proc "p". + * Returns: 0 on success, an error number otherwise + * Locks: none + * References: vp must be a valid reference for the duration of the call + */ +int +extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, + void *data, size_t nbytes, struct proc *p, register_t *retval) +{ + struct uio auio, *auiop; + struct iovec aiov; + ssize_t cnt; + size_t size, *sizep; + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + /* + * Slightly unusual semantics: if the user provides a NULL data + * pointer, they don't want to receive the data, just the maximum + * read length. + */ + auiop = NULL; + sizep = NULL; + cnt = 0; + if (data != NULL) { + aiov.iov_base = data; + aiov.iov_len = nbytes; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_offset = 0; + if (nbytes > INT_MAX) { + error = EINVAL; + goto done; + } + auio.uio_resid = nbytes; + auio.uio_rw = UIO_READ; + auio.uio_segflg = UIO_USERSPACE; + auio.uio_procp = p; + auiop = &auio; + cnt = nbytes; + } else + sizep = &size; + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_getextattr(p->p_ucred, vp, attrnamespace, + attrname, &auio); + if (error) + goto done; +#endif + + error = VOP_GETEXTATTR(vp, attrnamespace, attrname, auiop, sizep, + p->p_ucred, p); + + if (auiop != NULL) { + cnt -= auio.uio_resid; + *retval = cnt; + } else + *retval = size; + +done: + VOP_UNLOCK(vp, 0, p); + return (error); +} + +int +sys_extattr_get_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_get_fd_args *uap = v; + struct file *fp; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + error = getvnode(p->p_fd, SCARG(uap, fd), &fp); + if (error) + return (error); + + error = extattr_get_vp((struct vnode *)fp->f_data, + SCARG(uap, attrnamespace), attrname, SCARG(uap, data), + SCARG(uap, nbytes), p, retval); + + FRELE(fp); + return (error); +} + +int +sys_extattr_get_file(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_get_file_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_get_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +int +sys_extattr_get_link(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_get_link_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_get_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +/* + * extattr_delete_vp(): Delete a named extended attribute on a file or + * directory + * + * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", + * kernelspace string pointer "attrname", proc "p" + * Returns: 0 on success, an error number otherwise + * Locks: none + * References: vp must be a valid reference for the duration of the call + */ +int +extattr_delete_vp(struct vnode *vp, int attrnamespace, const char *attrname, + struct proc *p) +{ + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_deleteextattr(p->p_ucred, vp, attrnamespace, + attrname); + if (error) { + VOP_UNLOCK(vp, 0, p); + return (error); + } +#endif + + error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, p->p_ucred, p); + if (error == EOPNOTSUPP) + error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, + p->p_ucred, p); + VOP_UNLOCK(vp, 0, p); + return (error); +} + +int +sys_extattr_delete_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_delete_fd_args *uap = v; + struct file *fp; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return (error); + + error = getvnode(p->p_fd, SCARG(uap, fd), &fp); + if (error) + return (error); + + error = extattr_delete_vp((struct vnode *)fp->f_data, + SCARG(uap, attrnamespace), attrname, p); + FRELE(fp); + return (error); +} + +int +sys_extattr_delete_file(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_delete_file_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return(error); + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return(error); + + error = extattr_delete_vp(nd.ni_vp, SCARG(uap, attrnamespace), + attrname, p); + vrele(nd.ni_vp); + return(error); +} + +int +sys_extattr_delete_link(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_delete_link_args *uap = v; + struct nameidata nd; + char attrname[EXTATTR_MAXNAMELEN]; + int error; + + error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, + NULL); + if (error) + return(error); + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return(error); + + error = extattr_delete_vp(nd.ni_vp, SCARG(uap, attrnamespace), + attrname, p); + vrele(nd.ni_vp); + return(error); +} + +/*- + * Retrieve a list of extended attributes on a file or directory. + * + * Arguments: unlocked vnode "vp", attribute namespace 'attrnamespace", + * userspace buffer pointer "data", buffer length "nbytes", + * proc "p". + * Returns: 0 on success, an error number otherwise + * Locks: none + * References: vp must be a valid reference for the duration of the call + */ +int +extattr_list_vp(struct vnode *vp, int attrnamespace, void *data, + size_t nbytes, struct proc *p, register_t *retval) +{ + struct uio auio, *auiop; + size_t size, *sizep; + struct iovec aiov; + ssize_t cnt; + int error; + + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + auiop = NULL; + sizep = NULL; + cnt = 0; + if (data != NULL) { + aiov.iov_base = data; + aiov.iov_len = nbytes; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_offset = 0; + if (nbytes > INT_MAX) { + error = EINVAL; + goto done; + } + auio.uio_resid = nbytes; + auio.uio_rw = UIO_READ; + auio.uio_segflg = UIO_USERSPACE; + auio.uio_procp = p; + auiop = &auio; + cnt = nbytes; + } else + sizep = &size; + +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_listextattr(p->p_ucred, vp, attrnamespace); + if (error) + goto done; +#endif + + error = VOP_LISTEXTATTR(vp, attrnamespace, auiop, sizep, + p->p_ucred, p); + + if (auiop != NULL) { + cnt -= auio.uio_resid; + *retval = cnt; + } else + *retval = size; + +done: + VOP_UNLOCK(vp, 0, p); + return (error); +} + + +int +sys_extattr_list_fd(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_list_fd_args *uap = v; + struct file *fp; + int error; + + error = getvnode(p->p_fd, SCARG(uap, fd), &fp); + if (error) + return (error); + + error = extattr_list_vp((struct vnode *)fp->f_data, + SCARG(uap, attrnamespace), SCARG(uap, data), SCARG(uap, nbytes), + p, retval); + + FRELE(fp); + return (error); +} + +int +sys_extattr_list_file(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_list_file_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_list_vp(nd.ni_vp, SCARG(uap, attrnamespace), + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +int +sys_extattr_list_link(struct proc *p, void *v, register_t *retval) +{ + struct sys_extattr_list_link_args *uap = v; + struct nameidata nd; + int error; + + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + error = namei(&nd); + if (error) + return (error); + + error = extattr_list_vp(nd.ni_vp, SCARG(uap, attrnamespace), + SCARG(uap, data), SCARG(uap, nbytes), p, retval); + + vrele(nd.ni_vp); + return (error); +} + +/* + * vn_ea_*(): Simplified in-kernel wrapper calls for extended attribute access. + * All calls pass in a NOCRED credential, authorizing as "kernel" access. The + * IO_NODELOCKED flag should be set in ioflg if the vnode is already locked. + */ + +int +vn_ea_get(struct vnode *vp, int ioflg, int nspace, const char *name, + int *buflen, char *buf, struct proc *p) +{ + struct uio auio; + struct iovec iov; + int error; + + iov.iov_len = *buflen; + iov.iov_base = buf; + + auio.uio_iov = &iov; + auio.uio_iovcnt = 1; + auio.uio_rw = UIO_READ; + auio.uio_segflg = UIO_SYSSPACE; + auio.uio_procp = p; + auio.uio_offset = 0; + auio.uio_resid = *buflen; + + if ((ioflg & IO_NODELOCKED) == 0) + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + KASSERT(VOP_ISLOCKED(vp)); + + /* Authorize attribute retrieval as kernel. */ + error = VOP_GETEXTATTR(vp, nspace, name, &auio, NULL, NOCRED, p); + + if ((ioflg & IO_NODELOCKED) == 0) + VOP_UNLOCK(vp, 0, p); + + if (error == 0) + *buflen = *buflen - auio.uio_resid; + + return (error); +} + +/* + * XXX failure mode if partially written? + */ +int +vn_ea_set(struct vnode *vp, int ioflg, int nspace, const char *name, + int buflen, char *buf, struct proc *p) +{ + struct uio auio; + struct iovec iov; + int error; + + iov.iov_len = buflen; + iov.iov_base = buf; + + auio.uio_iov = &iov; + auio.uio_iovcnt = 1; + auio.uio_rw = UIO_WRITE; + auio.uio_segflg = UIO_SYSSPACE; + auio.uio_procp = p; + auio.uio_offset = 0; + auio.uio_resid = buflen; + + if ((ioflg & IO_NODELOCKED) == 0) + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + KASSERT(VOP_ISLOCKED(vp)); + + /* Authorize attribute setting as kernel. */ + error = VOP_SETEXTATTR(vp, nspace, name, &auio, NOCRED, p); + + if ((ioflg & IO_NODELOCKED) == 0) + VOP_UNLOCK(vp, 0, p); + + return (error); +} + +int +vn_ea_rm(struct vnode *vp, int ioflg, int nspace, const char *name, + struct proc *p) +{ + int error; + + if ((ioflg & IO_NODELOCKED) == 0) + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + + KASSERT(VOP_ISLOCKED(vp)); + + /* Authorize attribute removal as kernel. */ + error = VOP_DELETEEXTATTR(vp, nspace, name, NOCRED, p); + if (error == EOPNOTSUPP) + error = VOP_SETEXTATTR(vp, nspace, name, NULL, NOCRED, p); + + if ((ioflg & IO_NODELOCKED) == 0) + VOP_UNLOCK(vp, 0, p); + + return (error); +} diff --git a/sys/kern/vfs_lookup.c b/sys/kern/vfs_lookup.c index f707830..af7bc7a 100644 --- a/sys/kern/vfs_lookup.c +++ b/sys/kern/vfs_lookup.c @@ -58,6 +58,10 @@ #include #include "systrace.h" +#ifdef MAC +#include +#endif + /* * Convert a pathname into a pointer to a vnode. * @@ -199,7 +203,17 @@ namei(struct nameidata *ndp) error = ELOOP; break; } +#ifdef MAC + /* XXX PM: FreeBSD has a check for NOMACCHECK. */ + error = mac_vnode_check_readlink(p->p_ucred, ndp->ni_vp); + if (error) + break; +#endif +#ifdef ANOUBIS + if (1) +#else if (ndp->ni_pathlen > 1) +#endif cp = pool_get(&namei_pool, PR_WAITOK); else cp = cnp->cn_pnbuf; @@ -215,7 +229,11 @@ namei(struct nameidata *ndp) error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { badlink: +#ifdef ANOUBIS + if (1) +#else if (ndp->ni_pathlen > 1) +#endif pool_put(&namei_pool, cp); break; } @@ -228,14 +246,32 @@ badlink: error = ENAMETOOLONG; goto badlink; } +#ifdef ANOUBIS + /* + * We no longer need the link's vnode. Unlock it before + * the call to mac_check_follow_link. + */ + vput(ndp->ni_vp); + if (1) { +#else if (ndp->ni_pathlen > 1) { +#endif +#ifdef ANOUBIS + error = mac_check_follow_link(ndp, cp, linklen); + if (error) { + ndp->ni_vp = NULL; + goto badlink; + } +#endif bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen); pool_put(&namei_pool, cnp->cn_pnbuf); cnp->cn_pnbuf = cp; } else cnp->cn_pnbuf[linklen] = '\0'; ndp->ni_pathlen += linklen; +#ifndef ANOUBIS vput(ndp->ni_vp); +#endif dp = ndp->ni_dvp; /* * Check if root directory should replace current directory. @@ -248,7 +284,12 @@ badlink: } pool_put(&namei_pool, cnp->cn_pnbuf); vrele(ndp->ni_dvp); +#ifdef ANOUBIS + if (ndp->ni_vp) + vput(ndp->ni_vp); +#else vput(ndp->ni_vp); +#endif ndp->ni_vp = NULL; return (error); } @@ -451,6 +492,14 @@ dirloop: /* * We now have a segment name to search for, and a directory to search. */ + +#ifdef MAC + /* XXX PM: FreeBSD has a check for NOMACCHECK. */ + error = mac_vnode_check_lookup(p->p_ucred, dp, cnp); + if (error) + goto bad; +#endif + ndp->ni_dvp = dp; ndp->ni_vp = NULL; cnp->cn_flags &= ~PDIRUNLOCK; diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c index 1d5c86a..0c81937 100644 --- a/sys/kern/vfs_subr.c +++ b/sys/kern/vfs_subr.c @@ -59,12 +59,18 @@ #include #include #include +#include +#include #include #include #include +#ifdef MAC +#include +#endif + enum vtype iftovt_tab[16] = { VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, @@ -387,6 +393,15 @@ getnewvnode(enum vtagtype tag, struct mount *mp, int (**vops)(void *), panic("Clean vnode has pending I/O's"); splx(s); #endif + +#ifdef MAC + /* + * The vnode is being recycled, but we call mac_vnode_destroy() + * here to be coherent with what FreeBSD does. + */ + mac_vnode_destroy(vp); +#endif + vp->v_flag = 0; vp->v_socket = 0; } @@ -394,6 +409,17 @@ getnewvnode(enum vtagtype tag, struct mount *mp, int (**vops)(void *), cache_purge(vp); vp->v_tag = tag; vp->v_op = vops; +#ifdef MAC + /* XXX PM: vp is not locked. */ + mac_vnode_init(vp); + if (mp != NULL && (mp->mnt_flag & MNT_MULTILABEL) == 0) + mac_vnode_associate_singlelabel(mp, vp); + /* + * XXX PM: If we are coming form getdevvp(), 'mp' being NULL is normal. + */ +/* else if (mp == NULL && vp->v_op != dead_vnodeop_p) */ +/* printf("NULL mp in getnewvnode()\n"); */ +#endif insmntque(vp, mp); *vpp = vp; vp->v_usecount = 1; @@ -1539,57 +1565,133 @@ vfs_export_lookup(struct mount *mp, struct netexport *nep, struct mbuf *nam) } /* - * Do the usual access checking. - * file_mode, uid and gid are from the vnode in question, - * while acc_mode and cred are from the VOP_ACCESS parameter list + * Common filesystem object access control check routine. Accepts a + * vnode's type, "mode", uid and gid, requested access mode and + * credentials. Returns 0 on success, or an errno on failure. */ int -vaccess(enum vtype type, mode_t file_mode, uid_t uid, gid_t gid, - mode_t acc_mode, struct ucred *cred) +vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid, + accmode_t accmode, struct ucred *cred) { - mode_t mask; + accmode_t dac_granted; + accmode_t priv_granted; - /* User id 0 always gets read/write access. */ - if (cred->cr_uid == 0) { - /* For VEXEC, at least one of the execute bits must be set. */ - if ((acc_mode & VEXEC) && type != VDIR && - (file_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0) - return EACCES; - return 0; - } + /* + * Look for a normal, non-privileged way to access the file/directory + * as requested. If it exists, go with that. + */ + + dac_granted = 0; + + /* Check the owner. */ + if (cred->cr_uid == file_uid) { + dac_granted |= VADMIN; + if (file_mode & S_IXUSR) + dac_granted |= VEXEC; + if (file_mode & S_IRUSR) + dac_granted |= VREAD; + if (file_mode & S_IWUSR) + dac_granted |= (VWRITE | VAPPEND); - mask = 0; + if ((accmode & dac_granted) == accmode) + return (0); - /* Otherwise, check the owner. */ - if (cred->cr_uid == uid) { - if (acc_mode & VEXEC) - mask |= S_IXUSR; - if (acc_mode & VREAD) - mask |= S_IRUSR; - if (acc_mode & VWRITE) - mask |= S_IWUSR; - return (file_mode & mask) == mask ? 0 : EACCES; + goto privcheck; } - /* Otherwise, check the groups. */ - if (cred->cr_gid == gid || groupmember(gid, cred)) { - if (acc_mode & VEXEC) - mask |= S_IXGRP; - if (acc_mode & VREAD) - mask |= S_IRGRP; - if (acc_mode & VWRITE) - mask |= S_IWGRP; - return (file_mode & mask) == mask ? 0 : EACCES; + /* Otherwise, check the groups (first match) */ + if (groupmember(file_gid, cred)) { + if (file_mode & S_IXGRP) + dac_granted |= VEXEC; + if (file_mode & S_IRGRP) + dac_granted |= VREAD; + if (file_mode & S_IWGRP) + dac_granted |= (VWRITE | VAPPEND); + + if ((accmode & dac_granted) == accmode) + return (0); + + goto privcheck; } /* Otherwise, check everyone else. */ - if (acc_mode & VEXEC) - mask |= S_IXOTH; - if (acc_mode & VREAD) - mask |= S_IROTH; - if (acc_mode & VWRITE) - mask |= S_IWOTH; - return (file_mode & mask) == mask ? 0 : EACCES; + if (file_mode & S_IXOTH) + dac_granted |= VEXEC; + if (file_mode & S_IROTH) + dac_granted |= VREAD; + if (file_mode & S_IWOTH) + dac_granted |= (VWRITE | VAPPEND); + if ((accmode & dac_granted) == accmode) + return (0); + +privcheck: + /* + * Build a privilege mask to determine if the set of privileges + * satisfies the requirements when combined with the granted mask + * from above. For each privilege, if the privilege is required, + * bitwise or the request type onto the priv_granted mask. + */ + priv_granted = 0; + + if (type == VDIR) { + /* + * For directories, use PRIV_VFS_LOOKUP to satisfy VEXEC + * requests, instead of PRIV_VFS_EXEC. + */ + if ((accmode & VEXEC) && ((dac_granted & VEXEC) == 0) && + !priv_check_cred(cred, PRIV_VFS_LOOKUP, 0)) + priv_granted |= VEXEC; + } else { + if ((accmode & VEXEC) && ((dac_granted & VEXEC) == 0) && + !priv_check_cred(cred, PRIV_VFS_EXEC, 0)) + priv_granted |= VEXEC; + } + + if ((accmode & VREAD) && ((dac_granted & VREAD) == 0) && + !priv_check_cred(cred, PRIV_VFS_READ, 0)) + priv_granted |= VREAD; + + if ((accmode & VWRITE) && ((dac_granted & VWRITE) == 0) && + !priv_check_cred(cred, PRIV_VFS_WRITE, 0)) + priv_granted |= (VWRITE | VAPPEND); + + if ((accmode & VADMIN) && ((dac_granted & VADMIN) == 0) && + !priv_check_cred(cred, PRIV_VFS_ADMIN, 0)) + priv_granted |= VADMIN; + + if ((accmode & (priv_granted | dac_granted)) == accmode) + return (0); /* XXX audit: privilege used */ + + return ((accmode & VADMIN) ? EPERM : EACCES); +} + +/* + * Credential check based on process requesting service, and per-attribute + * permissions. + */ +int +extattr_check_cred(struct vnode *vp, int attrnamespace, struct ucred *cred, + struct proc *p, int access) +{ + /* + * Kernel-invoked always succeeds. + */ + if (cred == NOCRED) + return (0); + + /* + * Do not allow privileged processes in jail to directly manipulate + * system attributes. + */ + switch (attrnamespace) { + case EXTATTR_NAMESPACE_SYSTEM: + /* Potentially should be: return (EPERM); */ + return (suser_ucred(cred)); + case EXTATTR_NAMESPACE_USER: + return (VOP_ACCESS(vp, access, cred, p)); + default: + return (EPERM); + } } /* @@ -1832,22 +1934,30 @@ vinvalbuf(struct vnode *vp, int flags, struct ucred *cred, struct proc *p, loop: s = splbio(); for (;;) { - if ((blist = LIST_FIRST(&vp->v_cleanblkhd)) && - (flags & V_SAVEMETA)) - while (blist && blist->b_lblkno < 0) - blist = LIST_NEXT(blist, b_vnbufs); - if (blist == NULL && - (blist = LIST_FIRST(&vp->v_dirtyblkhd)) && - (flags & V_SAVEMETA)) - while (blist && blist->b_lblkno < 0) - blist = LIST_NEXT(blist, b_vnbufs); - if (!blist) + blist = LIST_FIRST(&vp->v_cleanblkhd); + if (blist == NULL) + blist = LIST_FIRST(&vp->v_dirtyblkhd); + if (blist != NULL) { + if (flags & V_SAVEMETA) + while (blist && blist->b_lblkno < 0) + blist = LIST_NEXT(blist, b_vnbufs); + else if (flags & V_NORMAL) + while (blist && blist->b_flags & B_EXTATTR) + blist = LIST_NEXT(blist, b_vnbufs); + else if (flags & V_EXT) + while (blist && !(blist->b_flags & B_EXTATTR)) + blist = LIST_NEXT(blist, b_vnbufs); + } + if (blist == NULL) break; - for (bp = blist; bp; bp = nbp) { nbp = LIST_NEXT(bp, b_vnbufs); if (flags & V_SAVEMETA && bp->b_lblkno < 0) continue; + if (flags & V_NORMAL && bp->b_flags & B_EXTATTR) + continue; + if (flags & V_EXT && !(bp->b_flags & B_EXTATTR)) + continue; if (bp->b_flags & B_BUSY) { bp->b_flags |= B_WANTED; error = tsleep(bp, slpflag | (PRIBIO + 1), @@ -1874,7 +1984,7 @@ loop: brelse(bp); } } - if (!(flags & V_SAVEMETA) && + if (!(flags & V_SAVEMETA) && !(flags & (V_EXT | V_NORMAL)) && (!LIST_EMPTY(&vp->v_dirtyblkhd) || !LIST_EMPTY(&vp->v_cleanblkhd))) panic("vinvalbuf: flush failed"); splx(s); @@ -2291,3 +2401,23 @@ copy_statfs_info(struct statfs *sbp, const struct mount *mp) sizeof(struct ufs_args)); } +/* + * Mark for update the access time of the file if the filesystem + * supports VA_MARK_ATIME. This functionality is used by execve + * and mmap, so we want to avoid the synchronous I/O implied by + * directly setting va_atime for the sake of efficiency. + */ +void +vfs_mark_atime(struct vnode *vp, struct ucred *cred) +{ + struct vattr atimeattr; + + /* Device vnodes don't have amount. */ + if (!vp->v_mount) + return; + if ((vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0) { + VATTR_NULL(&atimeattr); + atimeattr.va_vaflags |= VA_MARK_ATIME; + (void)VOP_SETATTR(vp, &atimeattr, cred, curproc); + } +} diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c index 249c900..c7d92b9 100644 --- a/sys/kern/vfs_syscalls.c +++ b/sys/kern/vfs_syscalls.c @@ -59,6 +59,10 @@ #include #include +#ifdef MAC +#include +#endif + extern int suid_clear; int usermount = 0; /* sysctl: by default, users may not mount */ @@ -245,6 +249,13 @@ sys_mount(struct proc *p, void *v, register_t *retval) strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN); mp->mnt_vnodecovered = vp; mp->mnt_stat.f_owner = p->p_ucred->cr_uid; + +#ifdef MAC + /* XXX PM: mp is locked. */ + mac_mount_init(mp); + mac_mount_create(p->p_ucred, mp); +#endif + update: /* * Set the mount level flags. @@ -307,6 +318,10 @@ update: vrele(vp); } else { mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0; +#ifdef MAC + /* XXX PM: mp is locked. */ + mac_mount_destroy(mp); +#endif vfs_unbusy(mp); free(mp, M_MOUNT); vput(vp); @@ -455,6 +470,11 @@ dounmount(struct mount *mp, int flags, struct proc *p, struct vnode *olddp) if (!LIST_EMPTY(&mp->mnt_vnodelist)) panic("unmount: dangling vnode"); +#ifdef MAC + /* XXX PM: mp is locked. */ + mac_mount_destroy(mp); +#endif + vfs_unbusy(mp); free(mp, M_MOUNT); @@ -573,6 +593,11 @@ sys_statfs(struct proc *p, void *v, register_t *retval) mp = nd.ni_vp->v_mount; sp = &mp->mnt_stat; vrele(nd.ni_vp); +#ifdef MAC + error = mac_mount_check_stat(p->p_ucred, mp); + if (error) + return (error); +#endif if ((error = VFS_STATFS(mp, sp, p)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; @@ -603,6 +628,13 @@ sys_fstatfs(struct proc *p, void *v, register_t *retval) FRELE(fp); return (ENOENT); } +#ifdef MAC + error = mac_mount_check_stat(p->p_ucred, mp); + if (error) { + FRELE(fp); + return (error); + } +#endif sp = &mp->mnt_stat; error = VFS_STATFS(mp, sp, p); FRELE(fp); @@ -640,6 +672,13 @@ sys_getfsstat(struct proc *p, void *v, register_t *retval) nmp = CIRCLEQ_NEXT(mp, mnt_list); continue; } +#ifdef MAC + if (mac_mount_check_stat(p->p_ucred, mp)) { + nmp = CIRCLEQ_NEXT(mp, mnt_list); + vfs_unbusy(mp); + continue; + } +#endif if (sfsp && count < maxcount) { sp = &mp->mnt_stat; @@ -769,6 +808,14 @@ sys_chroot(struct proc *p, void *v, register_t *retval) SCARG(uap, path), p); if ((error = change_dir(&nd, p)) != 0) return (error); +#ifdef MAC + /* XXX PM: nd.ni_vp is not locked. */ + error = mac_vnode_check_chroot(p->p_ucred, nd.ni_vp); + if (error) { + vrele(nd.ni_vp); /* Release ref. acquired by change_dir(). */ + return (error); + } +#endif if (fdp->fd_rdir != NULL) { /* * A chroot() done inside a changed root environment does @@ -801,8 +848,18 @@ change_dir(struct nameidata *ndp, struct proc *p) error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); if (error) vput(vp); - else + else { +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_chdir(p->p_ucred, vp); + if (error) { + vput(vp); + return (error); + } +#endif VOP_UNLOCK(vp, 0, p); + } + return (error); } @@ -1009,30 +1066,78 @@ sys_fhopen(struct proc *p, void *v, register_t *retval) error = EOPNOTSUPP; goto bad; } + if (flags & FREAD) { if ((error = VOP_ACCESS(vp, VREAD, cred, p)) != 0) goto bad; } +#ifdef MAC + { + int mode = 0; + if (flags & (FWRITE | O_TRUNC)) { + if (vp->v_type == VDIR) { + error = EISDIR; + goto bad; + } + error = vn_writechk(vp); + if (error) + goto bad; + mode |= VWRITE; + if (flags & O_APPEND) + mode |= VAPPEND; + } + if (flags & FREAD) + mode |= VREAD; +#ifdef ANOUBIS + /* We cannot generate a path for sys_fhopen. */ + error = mac_vnode_check_open(p->p_ucred, vp, mode, NULL, NULL); +#else + error = mac_vnode_check_open(p->p_ucred, vp, mode); +#endif + if (error) + goto bad; + if (mode) { + error = VOP_ACCESS(vp, mode, cred, p); + if (error) + goto bad; + } + } +#else /* MAC */ if (flags & (FWRITE | O_TRUNC)) { + int wmode = VWRITE; + if (flags & O_APPEND) + wmode |= VAPPEND; if (vp->v_type == VDIR) { error = EISDIR; goto bad; } if ((error = vn_writechk(vp)) != 0 || - (error = VOP_ACCESS(vp, VWRITE, cred, p)) != 0) + (error = VOP_ACCESS(vp, wmode, cred, p)) != 0) goto bad; } +#endif /* MAC */ if (flags & O_TRUNC) { VATTR_NULL(&va); va.va_size = 0; +#ifdef MAC + /* XXX PM: I'm not sure this hook is in the right place. */ + error = mac_vnode_check_write(p->p_ucred, NOCRED, vp); + if (error) + goto bad; +#endif if ((error = VOP_SETATTR(vp, &va, cred, p)) != 0) goto bad; } - if ((error = VOP_OPEN(vp, flags, cred, p)) != 0) + if (flags & FWRITE) { + error = vn_writecount(vp); + if (error) + goto bad; + } + if ((error = VOP_OPEN(vp, flags, cred, p)) != 0) { + if (flags & FWRITE) + vp->v_writecount--; goto bad; - if (flags & FWRITE) - vp->v_writecount++; - + } /* done with modified vn_open, now finish what sys_open does. */ fp->f_flag = flags & FMASK; @@ -1142,6 +1247,11 @@ sys_fhstatfs(struct proc *p, void *v, register_t *retval) mp = vp->v_mount; sp = &mp->mnt_stat; vput(vp); +#ifdef MAC + error = mac_mount_check_stat(p->p_ucred, mp); + if (error) + return (error); +#endif if ((error = VFS_STATFS(mp, sp, p)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; @@ -1195,6 +1305,18 @@ sys_mknod(struct proc *p, void *v, register_t *retval) break; } } +#ifdef MAC + if (!error) { + error = mac_vnode_check_create(p->p_ucred, nd.ni_dvp, + &nd.ni_cnd, &vattr); + if (error == 0) { + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + error = relookup(nd.ni_dvp, &vp, &nd.ni_cnd); + if (error == 0 && vp) + error = EEXIST; + } + } +#endif if (!error) { error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); } else { @@ -1231,6 +1353,10 @@ sys_mkfifo(struct proc *p, void *v, register_t *retval) if ((error = namei(&nd)) != 0) return (error); if (nd.ni_vp != NULL) { +#ifdef MAC + error = EEXIST; + goto abort; +#else VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); if (nd.ni_dvp == nd.ni_vp) vrele(nd.ni_dvp); @@ -1238,11 +1364,35 @@ sys_mkfifo(struct proc *p, void *v, register_t *retval) vput(nd.ni_dvp); vrele(nd.ni_vp); return (EEXIST); +#endif /* MAC */ } VATTR_NULL(&vattr); vattr.va_type = VFIFO; vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask; +#ifdef MAC + error = mac_vnode_check_create(p->p_ucred, nd.ni_dvp, &nd.ni_cnd, + &vattr); + if (error) + goto abort; + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + error = relookup(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd); + if (error == 0 && nd.ni_vp) + error = EEXIST; + if (error) + goto abort; +#endif return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr)); +#ifdef MAC +abort: + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + if (nd.ni_dvp == nd.ni_vp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + if (nd.ni_vp) + vrele(nd.ni_vp); + return error; +#endif /* MAC */ #endif /* FIFO */ } @@ -1261,11 +1411,22 @@ sys_link(struct proc *p, void *v, register_t *retval) struct nameidata nd; int error; int flags; +#ifdef ANOUBIS + struct nameidata snd; + struct componentname *scnp = &snd.ni_cnd; + + NDINIT(&snd, LOOKUP, FOLLOW | WANTPARENT | SAVENAME, UIO_USERSPACE, + SCARG(uap, path), p); + if ((error = namei(&snd)) != 0) + return (error); + vp = snd.ni_vp; +#else NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; +#endif flags = LOCKPARENT; if (vp->v_type == VDIR) { @@ -1285,8 +1446,35 @@ sys_link(struct proc *p, void *v, register_t *retval) error = EEXIST; goto out; } +#ifdef MAC +#ifdef ANOUBIS + error = mac_vnode_check_link(p->p_ucred, nd.ni_dvp, vp, &nd.ni_cnd, snd.ni_dvp, scnp); + /* relookup the vnode because the vfs_getcwd_common call + * in SFS modifies ni_dvp->i_offset which is used by VOP_LINK + * to link the vnode. + * for now ignore the possible race, similar to ufs_vnops.c */ + if (!error) { + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + if ((error = relookup(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd)) != 0) { + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + goto out; + } + } +#else + error = mac_vnode_check_link(p->p_ucred, nd.ni_dvp, vp, &nd.ni_cnd); +#endif + if (error) { + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + vput(nd.ni_dvp); + goto out; + } +#endif error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd); out: +#ifdef ANOUBIS + vrele(snd.ni_dvp); + pool_put(&namei_pool, scnp->cn_pnbuf); +#endif vrele(vp); return (error); } @@ -1315,6 +1503,10 @@ sys_symlink(struct proc *p, void *v, register_t *retval) if ((error = namei(&nd)) != 0) goto out; if (nd.ni_vp) { +#ifdef MAC + error = EEXIST; + goto abort; +#else VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); if (nd.ni_dvp == nd.ni_vp) vrele(nd.ni_dvp); @@ -1323,13 +1515,37 @@ sys_symlink(struct proc *p, void *v, register_t *retval) vrele(nd.ni_vp); error = EEXIST; goto out; +#endif /* MAC */ } VATTR_NULL(&vattr); vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask; +#ifdef MAC + error = mac_vnode_check_create(p->p_ucred, nd.ni_dvp, &nd.ni_cnd, + &vattr); + if (error) + goto abort; + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + error = relookup(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd); + if (error == 0 && nd.ni_vp) + error = EEXIST; + if (error) + goto abort; +#endif error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); out: pool_put(&namei_pool, path); return (error); +#ifdef MAC +abort: + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + if (nd.ni_dvp == nd.ni_vp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + if (nd.ni_vp) + vrele(nd.ni_vp); + goto out; +#endif /* MAC */ } /* @@ -1346,8 +1562,18 @@ sys_unlink(struct proc *p, void *v, register_t *retval) int error; struct nameidata nd; +#ifdef ANOUBIS + /* + * NOTE: We do not actually need SAVESTART but setting + * it explicitly will prevent VOP_* from freeing the name buffer. + */ + struct componentname *cnp = &nd.ni_cnd; + NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF | SAVENAME | SAVESTART, + UIO_USERSPACE, SCARG(uap, path), p); +#else NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, SCARG(uap, path), p); +#endif if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -1366,10 +1592,44 @@ sys_unlink(struct proc *p, void *v, register_t *retval) goto out; } +#ifdef MAC + error = mac_vnode_check_unlink(p->p_ucred, nd.ni_dvp, vp, &nd.ni_cnd); +#ifdef ANOUBIS + /* relookup the vnode because the vfs_getcwd_common call + * in SFS modifies ni_dvp->i_offset which is used by VOP_REMOVE + * to unlink the vnode. + * for now ignore the possible race, similar to ufs_vnops.c */ + if (!error) { + if (nd.ni_dvp == vp) + vrele(vp); + else + vput(vp); + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + if ((error = relookup(nd.ni_dvp, &vp, cnp)) != 0) { + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + goto out; + } + } +#endif + if (error) { + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + if (nd.ni_dvp == vp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + vput(vp); + goto out; + } +#endif + (void)uvm_vnp_uncache(vp); error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); out: +#ifdef ANOUBIS + vrele(nd.ni_startdir); + pool_put(&namei_pool, cnp->cn_pnbuf); +#endif return (error); } @@ -1471,6 +1731,15 @@ sys_access(struct proc *p, void *v, register_t *retval) goto out1; vp = nd.ni_vp; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_access(cred, vp, flags); + if (error) { + vput(vp); + return (error); + } +#endif + /* Flags == 0 means only check for existence. */ if (SCARG(uap, flags)) { flags = 0; @@ -1651,6 +1920,15 @@ sys_chflags(struct proc *p, void *v, register_t *retval) } VATTR_NULL(&vattr); vattr.va_flags = SCARG(uap, flags); +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setflags(p->p_ucred, vp, + vattr.va_flags); + if (error) { + vput(vp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } out: @@ -1694,6 +1972,16 @@ sys_fchflags(struct proc *p, void *v, register_t *retval) } VATTR_NULL(&vattr); vattr.va_flags = SCARG(uap, flags); +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setflags(p->p_ucred, vp, + vattr.va_flags); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } out: @@ -1731,6 +2019,13 @@ sys_chmod(struct proc *p, void *v, register_t *retval) else { VATTR_NULL(&vattr); vattr.va_mode = SCARG(uap, mode) & ALLPERMS; +#ifdef MAC + error = mac_vnode_check_setmode(p->p_ucred, vp, vattr.va_mode); + if (error) { + vput(vp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } vput(vp); @@ -1765,6 +2060,14 @@ sys_fchmod(struct proc *p, void *v, register_t *retval) else { VATTR_NULL(&vattr); vattr.va_mode = SCARG(uap, mode) & ALLPERMS; +#ifdef MAC + error = mac_vnode_check_setmode(p->p_ucred, vp, vattr.va_mode); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } VOP_UNLOCK(vp, 0, p); @@ -1813,6 +2116,15 @@ sys_chown(struct proc *p, void *v, register_t *retval) vattr.va_uid = SCARG(uap, uid); vattr.va_gid = SCARG(uap, gid); vattr.va_mode = mode; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setowner(p->p_ucred, vp, vattr.va_uid, + vattr.va_gid); + if (error) { + vput(vp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } out: @@ -1861,6 +2173,15 @@ sys_lchown(struct proc *p, void *v, register_t *retval) vattr.va_uid = SCARG(uap, uid); vattr.va_gid = SCARG(uap, gid); vattr.va_mode = mode; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setowner(p->p_ucred, vp, vattr.va_uid, + vattr.va_gid); + if (error) { + vput(vp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } out: @@ -1907,6 +2228,16 @@ sys_fchown(struct proc *p, void *v, register_t *retval) vattr.va_uid = SCARG(uap, uid); vattr.va_gid = SCARG(uap, gid); vattr.va_mode = mode; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setowner(p->p_ucred, vp, vattr.va_uid, + vattr.va_gid); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } out: @@ -1960,6 +2291,15 @@ sys_utimes(struct proc *p, void *v, register_t *retval) vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000; vattr.va_mtime.tv_sec = tv[1].tv_sec; vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setutimes(p->p_ucred, vp, + vattr.va_atime, vattr.va_mtime); + if (error) { + vput(vp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } vput(vp); @@ -2010,6 +2350,16 @@ sys_futimes(struct proc *p, void *v, register_t *retval) vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000; vattr.va_mtime.tv_sec = tv[1].tv_sec; vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_setutimes(p->p_ucred, vp, + vattr.va_atime, vattr.va_mtime); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); } VOP_UNLOCK(vp, 0, p); @@ -2033,8 +2383,16 @@ sys_truncate(struct proc *p, void *v, register_t *retval) struct vattr vattr; int error; struct nameidata nd; +#ifdef ANOUBIS + struct componentname *cnp = NULL; + struct vnode *dirvp = NULL; + NDINIT(&nd, LOOKUP, FOLLOW | SAVENAME | SAVESTART, + UIO_USERSPACE, SCARG(uap, path), p); +#else NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); +#endif + if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -2043,6 +2401,32 @@ sys_truncate(struct proc *p, void *v, register_t *retval) error = EISDIR; else if ((error = vn_writechk(vp)) == 0 && (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) { +#ifdef MAC + /* XXX PM: vp is locked. */ +#ifdef ANOUBIS + dirvp = nd.ni_dvp; + VREF(dirvp); + cnp = &nd.ni_cnd; + if (nd.ni_startdir) + vrele(nd.ni_startdir); + + error = mac_vnode_check_truncate(p->p_ucred, vp, dirvp, cnp); + + vrele(dirvp); + if (cnp->cn_flags & HASBUF) + pool_put(&namei_pool, cnp->cn_pnbuf); + + if (error) { + vput(vp); + return (error); + } +#endif + error = mac_vnode_check_write(p->p_ucred, NOCRED, vp); + if (error) { + vput(vp); + return (error); + } +#endif VATTR_NULL(&vattr); vattr.va_size = SCARG(uap, length); error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); @@ -2081,6 +2465,23 @@ sys_ftruncate(struct proc *p, void *v, register_t *retval) if (vp->v_type == VDIR) error = EISDIR; else if ((error = vn_writechk(vp)) == 0) { +#ifdef MAC + /* XXX PM: vp is locked. */ +#ifdef ANOUBIS + error = mac_vnode_check_truncate(p->p_ucred, vp, NULL, NULL); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif + error = mac_vnode_check_write(p->p_ucred, fp->f_cred, vp); + if (error) { + VOP_UNLOCK(vp, 0, p); + FRELE(fp); + return (error); + } +#endif VATTR_NULL(&vattr); vattr.va_size = len; error = VOP_SETATTR(vp, &vattr, fp->f_cred, p); @@ -2141,6 +2542,19 @@ sys_rename(struct proc *p, void *v, register_t *retval) SCARG(uap, from), p); if ((error = namei(&fromnd)) != 0) return (error); +#ifdef MAC + error = mac_vnode_check_rename_from(p->p_ucred, fromnd.ni_dvp, + fromnd.ni_vp, &fromnd.ni_cnd); + if (error) { + VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); + vrele(fromnd.ni_dvp); + vrele(fromnd.ni_vp); + if (fromnd.ni_startdir) + vrele(fromnd.ni_startdir); + pool_put(&namei_pool, fromnd.ni_cnd.cn_pnbuf); + return (error); + } +#endif fvp = fromnd.ni_vp; flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART; @@ -2177,6 +2591,37 @@ sys_rename(struct proc *p, void *v, register_t *retval) */ if (fvp == tvp) error = -1; +#ifdef MAC + else + error = mac_vnode_check_rename_to(p->p_ucred, tdvp, tvp, + fromnd.ni_dvp == tdvp, &tond.ni_cnd); +#ifdef ANOUBIS + if (!error) + error = mac_vnode_check_rename_an(p->p_ucred, tdvp, tvp, + fromnd.ni_dvp, &tond.ni_cnd, &fromnd.ni_cnd); + /* relookup the vnode because the vfs_getcwd_common call + * in SFS modifies ni_dvp->i_offset which is used by VOP_RENAME + * to rename the vnode. + * for now ignore the possible race, similar to ufs_vnops.c */ + if (!error) { + vrele(fvp); + if ((error = relookup(fromnd.ni_dvp, &fvp, &fromnd.ni_cnd)) != 0) { + fvp = NULL; + goto out; + } + } + if (!error) { + if (tdvp == tvp) + vrele(tvp); + else if (tvp) + vput(tvp); + VOP_UNLOCK(tdvp, 0, curproc); + if ((error = relookup(tdvp, &tvp, &tond.ni_cnd)) != 0) { + goto out; + } + } +#endif +#endif out: if (!error) { if (tvp) { @@ -2194,7 +2639,8 @@ out: vput(tvp); VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); vrele(fromnd.ni_dvp); - vrele(fvp); + if (fvp) + vrele(fvp); } vrele(tond.ni_startdir); pool_put(&namei_pool, tond.ni_cnd.cn_pnbuf); @@ -2229,6 +2675,10 @@ sys_mkdir(struct proc *p, void *v, register_t *retval) return (error); vp = nd.ni_vp; if (vp != NULL) { +#ifdef MAC + error = EEXIST; + goto abort; +#else VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); if (nd.ni_dvp == vp) vrele(nd.ni_dvp); @@ -2236,14 +2686,38 @@ sys_mkdir(struct proc *p, void *v, register_t *retval) vput(nd.ni_dvp); vrele(vp); return (EEXIST); +#endif /* MAC */ } VATTR_NULL(&vattr); vattr.va_type = VDIR; vattr.va_mode = (SCARG(uap, mode) & ACCESSPERMS) &~ p->p_fd->fd_cmask; +#ifdef MAC + error = mac_vnode_check_create(p->p_ucred, nd.ni_dvp, &nd.ni_cnd, + &vattr); + if (error) + goto abort; + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + error = relookup(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd); + if (error == 0 && nd.ni_vp) + error = EEXIST; + if (error) + goto abort; +#endif error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); if (!error) vput(nd.ni_vp); return (error); +#ifdef MAC +abort: + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + if (nd.ni_dvp == nd.ni_vp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + if (nd.ni_vp) + vrele(nd.ni_vp); + return error; +#endif /* MAC */ } /* @@ -2260,8 +2734,17 @@ sys_rmdir(struct proc *p, void *v, register_t *retval) int error; struct nameidata nd; +#ifdef ANOUBIS + /* + * NOTE: We do not actually need SAVESTART but setting + * it explicitly will prevent VOP_* from freeing the name buffer. + */ + NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF | SAVENAME | SAVESTART, + UIO_USERSPACE, SCARG(uap, path), p); +#else NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, SCARG(uap, path), p); +#endif if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -2282,6 +2765,29 @@ sys_rmdir(struct proc *p, void *v, register_t *retval) if (vp->v_flag & VROOT) error = EBUSY; out: +#ifdef MAC + if (!error) + error = mac_vnode_check_unlink(p->p_ucred, nd.ni_dvp, vp, + &nd.ni_cnd); +#ifdef ANOUBIS + /* + * relookup the vnode because the vfs_getcwd_common call + * in SFS modifies ni_dvp->i_offset which is used by VOP_RMDIR + * to unlink the vnode. + */ + if (!error) { + if (nd.ni_dvp == vp) + vrele(vp); + else + vput(vp); + VOP_UNLOCK(nd.ni_dvp, 0, curproc); + if ((error = relookup(nd.ni_dvp, &vp, &nd.ni_cnd)) != 0) { + VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); + goto done; + } + } +#endif +#endif if (!error) { error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); } else { @@ -2292,6 +2798,11 @@ out: vput(nd.ni_dvp); vput(vp); } +#ifdef ANOUBIS +done: + vrele(nd.ni_startdir); + pool_put(&namei_pool, nd.ni_cnd.cn_pnbuf); +#endif return (error); } @@ -2337,6 +2848,14 @@ sys_getdirentries(struct proc *p, void *v, register_t *retval) auio.uio_resid = SCARG(uap, count); vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); loff = auio.uio_offset = fp->f_offset; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_readdir(p->p_ucred, vp); + if (error) { + VOP_UNLOCK(vp, 0, p); + goto bad; + } +#endif error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, 0, 0); fp->f_offset = auio.uio_offset; VOP_UNLOCK(vp, 0, p); @@ -2392,6 +2911,12 @@ sys_revoke(struct proc *p, void *v, register_t *retval) if (p->p_ucred->cr_uid != vattr.va_uid && (error = suser(p, 0))) goto out; +#ifdef MAC + /* XXX PM: vp is not locked. */ + error = mac_vnode_check_revoke(p->p_ucred, vp); + if (error) + goto out; +#endif if (vp->v_usecount > 1 || (vp->v_flag & (VALIASED))) VOP_REVOKE(vp, REVOKEALL); out: diff --git a/sys/kern/vfs_vnops.c b/sys/kern/vfs_vnops.c index 562b074..0c5ae5d 100644 --- a/sys/kern/vfs_vnops.c +++ b/sys/kern/vfs_vnops.c @@ -44,6 +44,7 @@ #include #include #include +#include #include #include #include @@ -57,6 +58,10 @@ #include #include +#ifdef MAC +#include +#endif + int vn_read(struct file *, off_t *, struct uio *, struct ucred *); int vn_write(struct file *, off_t *, struct uio *, struct ucred *); int vn_poll(struct file *, int, struct proc *); @@ -80,6 +85,11 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) struct vattr va; struct cloneinfo *cip; int error; +#ifdef ANOUBIS + struct componentname *cnp = NULL; + struct vnode *dirvp = NULL; + struct nameidata savendp = *ndp; +#endif if ((fmode & (FREAD|FWRITE)) == 0) return (EINVAL); @@ -87,22 +97,86 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) return (EINVAL); if (fmode & O_CREAT) { ndp->ni_cnd.cn_nameiop = CREATE; +#ifdef ANOUBIS + /* + * NOTE: We do not actually need SAVESTART but setting + * it explicitly will prevent VOP_ABORTOP from freeing + * the name buffer. + */ + ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF + | SAVENAME | SAVESTART; +#else ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; +#endif if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0) ndp->ni_cnd.cn_flags |= FOLLOW; if ((error = namei(ndp)) != 0) return (error); - +#ifdef ANOUBIS + dirvp = ndp->ni_dvp; + VREF(dirvp); + cnp = &ndp->ni_cnd; + if (ndp->ni_startdir) + vrele(ndp->ni_startdir); +#endif if (ndp->ni_vp == NULL) { VATTR_NULL(&va); va.va_type = VREG; va.va_mode = cmode; if (fmode & O_EXCL) va.va_vaflags |= VA_EXCLUSIVE; +#ifdef MAC + /* XXX PM: ndp->ni_dvp is locked. */ + error = mac_vnode_check_create(cred, ndp->ni_dvp, + &ndp->ni_cnd, &va); + if (error) { +#ifdef ANOUBIS + if (dirvp) { + pool_put(&namei_pool, cnp->cn_pnbuf); + vrele(dirvp); + } +#endif + vput(dirvp); + return error; + } + /* + * relookup the vnode. The call to check_create has + * changed the directory information in the file + * system specific part of the inode. + */ + VOP_UNLOCK(ndp->ni_dvp, 0, curproc); + error = relookup(ndp->ni_dvp, &ndp->ni_vp, cnp); + if (error != 0) { + if (dirvp) + vrele(dirvp); + pool_put(&namei_pool, cnp->cn_pnbuf); + vput(dirvp); + return error; + } + /* + * relookup plus SAVESTART, i.e. we get another + * reference to dirvp that we do not need. + */ + if (dirvp) + vrele(dirvp); +#endif error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp, - &ndp->ni_cnd, &va); + &ndp->ni_cnd, &va); +#ifdef ANOUBIS + if (error) { + if (dirvp) + vrele(dirvp); + /* + * No need to free cnp->cn_pnbuf here as + * VOP_CREATE does this on error. This is + * independent of SAVESTART. + */ + return (error); + } +#else if (error) return (error); +#endif fmode &= ~O_TRUNC; vp = ndp->ni_vp; } else { @@ -113,6 +187,10 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) vput(ndp->ni_dvp); ndp->ni_dvp = NULL; vp = ndp->ni_vp; +#ifdef MAC + if (error) + goto bad; +#endif if (fmode & O_EXCL) { error = EEXIST; goto bad; @@ -121,10 +199,39 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) } } else { ndp->ni_cnd.cn_nameiop = LOOKUP; +#ifdef ANOUBIS + ndp->ni_cnd.cn_flags = WANTPARENT | SAVENAME | + ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) | LOCKLEAF; +#else ndp->ni_cnd.cn_flags = ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) | LOCKLEAF; +#endif +#ifdef ANOUBIS + /* + * If error == EISDIR we are doing a lookup on some alias + * of '/'. We do not want to return an error in this case + * but namei unfortunately returns EISDIR if WANTPARENT is + * set. Thus redo the lookup without WANTPARENT and remember + * that we do not have dirvp/cnp which is ok for directories. + */ + error = namei(ndp); + if (error) { + if (error != EISDIR) + return error; + *ndp = savendp; + ndp->ni_cnd.cn_nameiop = LOOKUP; + ndp->ni_cnd.cn_flags = LOCKLEAF | + ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW); + if ((error = namei(ndp))) + return (error); + } else { + dirvp = ndp->ni_dvp; + cnp = &ndp->ni_cnd; + } +#else if ((error = namei(ndp)) != 0) return (error); +#endif vp = ndp->ni_vp; } if (vp->v_type == VSOCK) { @@ -135,18 +242,66 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) error = EMLINK; goto bad; } +#ifdef ANOUBIS + /* + * We do not have dirvp and cnp because the first lookup above + * returned EISDIR. Verify that the second lookup did return a + * directory. Otherwise someone messed with the namespace or with + * pathname in user space between the two lookups. + */ + if (!cnp && vp->v_type != VDIR) { + error = ENOTDIR; + goto bad; + } +#endif +#ifdef MAC + { + int mode = 0; + if (fmode & (FWRITE | O_TRUNC | O_APPEND)) + mode |= VWRITE; + if (fmode & FREAD) + mode |= VREAD; + if (fmode & O_APPEND) + mode |= VAPPEND; +#ifdef ANOUBIS + /* + * XXX PM: 'vp' is locked, 'dirvp' is not. + */ + error = mac_vnode_check_open(cred, vp, mode, dirvp, cnp); + if (dirvp) + vrele(dirvp); + if (cnp) { + if ((cnp->cn_flags & HASBUF) == 0) + panic("Lost buffer in vn_open?"); + pool_put(&namei_pool, cnp->cn_pnbuf); + } + dirvp = NULL; + cnp = NULL; +#else + /* + * XXX PM: 'vp' is locked, 'dirvp' is not. + */ + error = mac_vnode_check_open(cred, vp, mode); +#endif + if (error) + goto bad; + } +#endif if ((fmode & O_CREAT) == 0) { if (fmode & FREAD) { if ((error = VOP_ACCESS(vp, VREAD, cred, p)) != 0) goto bad; } if (fmode & FWRITE) { + int wmode = VWRITE; + if (fmode & O_APPEND) + wmode |= VAPPEND; if (vp->v_type == VDIR) { error = EISDIR; goto bad; } if ((error = vn_writechk(vp)) != 0 || - (error = VOP_ACCESS(vp, VWRITE, cred, p)) != 0) + (error = VOP_ACCESS(vp, wmode, cred, p)) != 0) goto bad; } } @@ -156,10 +311,20 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) if ((error = VOP_SETATTR(vp, &va, cred, p)) != 0) goto bad; } - if ((error = VOP_OPEN(vp, fmode, cred, p)) != 0) + if (fmode & FWRITE) { + error = vn_writecount(vp); + if (error) + goto bad; + } + if ((error = VOP_OPEN(vp, fmode, cred, p)) != 0) { + if (fmode & FWRITE) + vp->v_writecount--; goto bad; + } if (vp->v_flag & VCLONED) { + if (fmode & FWRITE) + vp->v_writecount--; cip = (struct cloneinfo *)vp->v_data; vp->v_flag &= ~VCLONED; @@ -170,12 +335,18 @@ vn_open(struct nameidata *ndp, int fmode, int cmode) vp = ndp->ni_vp; /* for the increment below */ free(cip, M_TEMP); + if (vn_writecount(vp)) + panic("vn_open: Cannot increment write count of clone"); } - if (fmode & FWRITE) - vp->v_writecount++; return (0); bad: +#ifdef ANOUBIS + if (dirvp) + vrele(dirvp); + if (cnp) + pool_put(&namei_pool, cnp->cn_pnbuf); +#endif vput(vp); return (error); } @@ -228,6 +399,41 @@ vn_marktext(struct vnode *vp) } /* + * Increment the vnodes v_writecount if it is potentially zero. + * This can fail if u_denywrite is set in the uvm_vnode. + */ +int +vn_writecount(struct vnode *vp) +{ + int error = 0; + simple_lock(&vp->v_uvm.u_obj.vmobjlock); + if (vp->v_denywrite || + ((vp->v_uvm.u_flags & UVM_VNODE_VALID) && vp->v_uvm.u_denywrite)) { + assert(vp->v_writecount == 0); + error = EBUSY; + } else { + vp->v_writecount++; + } + simple_unlock(&vp->v_uvm.u_obj.vmobjlock); + return error; +} + +int vn_denywrite(struct vnode *vp) +{ + int error = 0; + simple_lock(&vp->v_uvm.u_obj.vmobjlock); + if (vp->v_writecount || + ((vp->v_uvm.u_flags & UVM_VNODE_VALID) && vp->v_uvm.u_writecount)) { + assert(vp->v_denywrite == 0); + error = EBUSY; + } else { + vp->v_denywrite++; + } + simple_unlock(&vp->v_uvm.u_obj.vmobjlock); + return error; +} + +/* * Vnode close call */ int @@ -266,10 +472,25 @@ vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base, int len, off_t offset, auio.uio_segflg = segflg; auio.uio_rw = rw; auio.uio_procp = p; + /* XXX PM: FreeBSD has a 'IO_NOMACCHECK' flag. */ if (rw == UIO_READ) { +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_read(cred, NOCRED, vp); + if (error == 0) + error = VOP_READ(vp, &auio, ioflg, cred); +#else error = VOP_READ(vp, &auio, ioflg, cred); +#endif } else { +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_write(cred, NOCRED, vp); + if (error == 0) + error = VOP_WRITE(vp, &auio, ioflg, cred); +#else error = VOP_WRITE(vp, &auio, ioflg, cred); +#endif } if (aresid) *aresid = auio.uio_resid; @@ -295,6 +516,14 @@ vn_read(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); uio->uio_offset = *poff; count = uio->uio_resid; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_read(cred, fp->f_cred, vp); + if (error) { + VOP_UNLOCK(vp, 0, p); + return (error); + } +#endif if (vp->v_type != VDIR) error = VOP_READ(vp, uio, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred); @@ -324,6 +553,14 @@ vn_write(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); uio->uio_offset = *poff; count = uio->uio_resid; +#ifdef MAC + /* XXX PM: vp is locked. */ + error = mac_vnode_check_write(cred, fp->f_cred, vp); + if (error) { + VOP_UNLOCK(vp, 0, p); + return (error); + } +#endif error = VOP_WRITE(vp, uio, ioflag, cred); if (ioflag & IO_APPEND) *poff = uio->uio_offset; @@ -353,6 +590,14 @@ vn_stat(struct vnode *vp, struct stat *sb, struct proc *p) int error; mode_t mode; +#ifdef MAC + /* XXX PM: vp is locked. */ + /* XXX PM: should be able to pass 'fp->f_cred' here. */ + error = mac_vnode_check_stat(p->p_ucred, NOCRED, vp); + if (error) + return (error); +#endif + error = VOP_GETATTR(vp, &va, p->p_ucred, p); if (error) return (error); @@ -450,6 +695,15 @@ vn_ioctl(struct file *fp, u_long com, caddr_t data, struct proc *p) int vn_poll(struct file *fp, int events, struct proc *p) { +#ifdef MAC + int error; + + /* XXX PM: vnode is unlocked. */ + error = mac_vnode_check_poll(p->p_ucred, fp->f_cred, + (struct vnode *)fp->f_data); + if (error) + return (error); +#endif return (VOP_POLL(((struct vnode *)fp->f_data), events, p)); } diff --git a/sys/kern/vnode_if.c b/sys/kern/vnode_if.c index a5fa078..35ff3af 100644 --- a/sys/kern/vnode_if.c +++ b/sys/kern/vnode_if.c @@ -3,9 +3,9 @@ * (Modifications made here may easily be lost!) * * Created from the file: - * OpenBSD: vnode_if.src,v 1.32 2007/01/16 17:52:18 thib Exp + * OpenBSD * by the script: - * OpenBSD: vnode_if.sh,v 1.16 2007/12/12 16:24:49 thib Exp + * OpenBSD: thib */ /* @@ -675,6 +675,153 @@ int VOP_REALLOCBLKS(struct vnode *vp, struct cluster_save *buflist) a.a_buflist = buflist; return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); } +struct vnodeop_desc vop_getextattr_desc = { + 0, + "vop_getextattr", + 0, +}; + +int VOP_GETEXTATTR(struct vnode *vp, int attrnamespace, const char *name, + struct uio *uio, size_t *size, struct ucred *cred, struct proc *p) +{ + struct vop_getextattr_args a; + a.a_desc = VDESC(vop_getextattr); + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_uio = uio; + a.a_size = size; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_getextattr), &a)); +} +struct vnodeop_desc vop_listextattr_desc = { + 0, + "vop_listextattr", + 0, +}; + +int VOP_LISTEXTATTR(struct vnode *vp, int attrnamespace, struct uio *uio, + size_t *size, struct ucred *cred, struct proc *p) +{ + struct vop_listextattr_args a; + a.a_desc = VDESC(vop_listextattr); + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_uio = uio; + a.a_size = size; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_listextattr), &a)); +} +struct vnodeop_desc vop_deleteextattr_desc = { + 0, + "vop_deleteextattr", + 0, +}; + +int VOP_DELETEEXTATTR(struct vnode *vp, int attrnamespace, const char *name, + struct ucred *cred, struct proc *p) +{ + struct vop_deleteextattr_args a; + a.a_desc = VDESC(vop_deleteextattr); + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); +} +struct vnodeop_desc vop_setextattr_desc = { + 0, + "vop_setextattr", + 0, +}; + +int VOP_SETEXTATTR(struct vnode *vp, int attrnamespace, const char *name, + struct uio *uio, struct ucred *cred, struct proc *p) +{ + struct vop_setextattr_args a; + a.a_desc = VDESC(vop_setextattr); + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_uio = uio; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_setextattr), &a)); +} +struct vnodeop_desc vop_getacl_desc = { + 0, + "vop_getacl", + 0, +}; + +int VOP_GETACL(struct vnode *vp, acl_type_t type, struct acl *aclp, + struct ucred *cred, struct proc *p) +{ + struct vop_getacl_args a; + a.a_desc = VDESC(vop_getacl); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_getacl), &a)); +} +struct vnodeop_desc vop_setacl_desc = { + 0, + "vop_setacl", + 0, +}; + +int VOP_SETACL(struct vnode *vp, acl_type_t type, struct acl *aclp, + struct ucred *cred, struct proc *p) +{ + struct vop_setacl_args a; + a.a_desc = VDESC(vop_setacl); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_setacl), &a)); +} +struct vnodeop_desc vop_aclcheck_desc = { + 0, + "vop_aclcheck", + 0, +}; + +int VOP_ACLCHECK(struct vnode *vp, acl_type_t type, struct acl *aclp, + struct ucred *cred, struct proc *p) +{ + struct vop_aclcheck_args a; + a.a_desc = VDESC(vop_aclcheck); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_aclcheck), &a)); +} +struct vnodeop_desc vop_setlabel_desc = { + 0, + "vop_setlabel", + 0, +}; + +int VOP_SETLABEL(struct vnode *vp, struct label *label, struct ucred *cred, + struct proc *p) +{ + struct vop_setlabel_args a; + a.a_desc = VDESC(vop_setlabel); + a.a_vp = vp; + a.a_label = label; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_setlabel), &a)); +} /* Special cases: */ struct vnodeop_desc vop_strategy_desc = { @@ -745,6 +892,14 @@ struct vnodeop_desc *vfs_op_descs[] = { &vop_pathconf_desc, &vop_advlock_desc, &vop_reallocblks_desc, + &vop_getextattr_desc, + &vop_listextattr_desc, + &vop_deleteextattr_desc, + &vop_setextattr_desc, + &vop_getacl_desc, + &vop_setacl_desc, + &vop_aclcheck_desc, + &vop_setlabel_desc, NULL }; diff --git a/sys/kern/vnode_if.src b/sys/kern/vnode_if.src index 421b626..af662e5 100644 --- a/sys/kern/vnode_if.src +++ b/sys/kern/vnode_if.src @@ -1,4 +1,4 @@ -# $OpenBSD: thib $ +# $OpenBSD$ # $NetBSD: vnode_if.src,v 1.10 1996/05/11 18:26:27 mycroft Exp $ # # Copyright (c) 1992, 1993 @@ -437,3 +437,86 @@ vop_reallocblks { #vop_bwrite { # IN struct buf *bp; #}; + +#% getextattr vp L L L + +vop_getextattr { + IN struct vnode *vp; + IN int attrnamespace; + IN const char *name; + INOUT struct uio *uio; + OUT size_t *size; + IN struct ucred *cred; + IN struct proc *p; +}; + +#% listextattr vp L L L + +vop_listextattr { + IN struct vnode *vp; + IN int attrnamespace; + INOUT struct uio *uio; + OUT size_t *size; + IN struct ucred *cred; + IN struct proc *p; +}; + +#% deleteextattr vp L L L + +vop_deleteextattr { + IN struct vnode *vp; + IN int attrnamespace; + IN const char *name; + IN struct ucred *cred; + IN struct proc *p; +}; + +#% setextattr vp L L L + +vop_setextattr { + IN struct vnode *vp; + IN int attrnamespace; + IN const char *name; + INOUT struct uio *uio; + IN struct ucred *cred; + IN struct proc *p; +}; + +#% getacl vp L L L + +vop_getacl { + IN struct vnode *vp; + IN acl_type_t type; + OUT struct acl *aclp; + IN struct ucred *cred; + IN struct proc *p; +} + +#% setacl vp L L L + +vop_setacl { + IN struct vnode *vp; + IN acl_type_t type; + IN struct acl *aclp; + IN struct ucred *cred; + IN struct proc *p; +} + +#% aclcheck vp = = = + +vop_aclcheck { + IN struct vnode *vp; + IN acl_type_t type; + IN struct acl *aclp; + IN struct ucred *cred; + IN struct proc *p; +} + +#% setlabel vp L L L + +vop_setlabel { + IN struct vnode *vp; + IN struct label *label; + IN struct ucred *cred; + IN struct proc *p; +}; diff --git a/sys/lib/libkern/libkern.h b/sys/lib/libkern/libkern.h index 5a3d321..d219e4f 100644 --- a/sys/lib/libkern/libkern.h +++ b/sys/lib/libkern/libkern.h @@ -161,6 +161,7 @@ int strcmp(const char *, const char *); int strncmp(const char *, const char *, size_t); int strncasecmp(const char *, const char *, size_t); int getsn(char *, int); +char *strsep(char **, const char *); char *strchr(const char *, int); char *strrchr(const char *, int); diff --git a/sys/lib/libkern/strsep.c b/sys/lib/libkern/strsep.c new file mode 100644 index 0000000..afa0139 --- /dev/null +++ b/sys/lib/libkern/strsep.c @@ -0,0 +1,76 @@ +/* $OpenBSD: strsep.c,v 1.6 2005/08/08 08:05:37 espie Exp $ */ + +/* + * Copyright (c) 1990, 1993 + * The Regents of the University of California. 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. + */ + +#if !defined(_KERNEL) && !defined(_STANDALONE) +#include +#include +#else +#include +#include +#endif + +/* + * Get next token from string *stringp, where tokens are possibly-empty + * strings separated by characters from delim. + * + * Writes NULs into the string at *stringp to end tokens. + * delim need not remain constant from call to call. + * On return, *stringp points past the last NUL written (if there might + * be further tokens), or is NULL (if there are definitely no more tokens). + * + * If *stringp is NULL, strsep returns NULL. + */ +char * +strsep(char **stringp, const char *delim) +{ + char *s; + const char *spanp; + int c, sc; + char *tok; + + if ((s = *stringp) == NULL) + return (NULL); + for (tok = s;;) { + c = *s++; + spanp = delim; + do { + if ((sc = *spanp++) == c) { + if (c == 0) + s = NULL; + else + s[-1] = 0; + *stringp = s; + return (tok); + } + } while (sc != 0); + } + /* NOTREACHED */ +} diff --git a/sys/miscfs/procfs/procfs_ctl.c b/sys/miscfs/procfs/procfs_ctl.c index 869a886..b13f87e 100644 --- a/sys/miscfs/procfs/procfs_ctl.c +++ b/sys/miscfs/procfs/procfs_ctl.c @@ -51,6 +51,10 @@ #include #include +#ifdef MAC +#include +#endif + /* * True iff process (p) is in trace wait state * relative to process (curp) @@ -127,6 +131,12 @@ procfs_control(struct proc *curp, struct proc *p, int op) if ((error = process_checkioperm(curp, p)) != 0) return (error); +#ifdef MAC + error = mac_proc_check_debug(curp->p_ucred, p); + if (error) + return (error); +#endif + /* * Go ahead and set the trace flag. * Save the old parent (it's reset in diff --git a/sys/miscfs/procfs/procfs_subr.c b/sys/miscfs/procfs/procfs_subr.c index 1a0be2b..9fc307e 100644 --- a/sys/miscfs/procfs/procfs_subr.c +++ b/sys/miscfs/procfs/procfs_subr.c @@ -48,6 +48,10 @@ #include +#ifdef MAC +#include +#endif + static TAILQ_HEAD(, pfsnode) pfshead; struct lock pfs_vlock; @@ -200,6 +204,9 @@ procfs_rw(void *v) struct proc *curp = uio->uio_procp; struct pfsnode *pfs = VTOPFS(vp); struct proc *p; +#ifdef MAC + int error; +#endif p = pfind(pfs->pfs_pid); if (p == 0) @@ -210,6 +217,12 @@ procfs_rw(void *v) if (uio->uio_offset < 0) return (EINVAL); +#ifdef MAC + error = mac_proc_check_debug(curp->p_ucred, p); + if (error) + return (error); +#endif + switch (pfs->pfs_type) { case Pnote: case Pnotepg: diff --git a/sys/net/bpf.c b/sys/net/bpf.c index 122880f..98bc36a 100644 --- a/sys/net/bpf.c +++ b/sys/net/bpf.c @@ -64,6 +64,10 @@ #include #endif +#ifdef MAC +#include +#endif + #define BPF_BUFSIZE 32768 #define PRINET 26 /* interruptible */ @@ -331,6 +335,10 @@ bpfopen(dev_t dev, int flag, int mode, struct proc *p) /* Mark "free" and do most initialization. */ d->bd_bufsize = bpf_bufsize; d->bd_sig = SIGIO; +#ifdef MAC + mac_bpfdesc_init(d); + mac_bpfdesc_create(p->p_ucred, d); +#endif D_GET(d); @@ -353,6 +361,9 @@ bpfclose(dev_t dev, int flag, int mode, struct proc *p) if (d->bd_bif) bpf_detachd(d); bpf_wakeup(d); +#ifdef MAC + mac_bpfdesc_destroy(d); +#endif D_PUT(d); splx(s); @@ -544,6 +555,9 @@ bpfwrite(dev_t dev, struct uio *uio, int ioflag) dst.ss_family = pseudo_AF_HDRCMPLT; s = splsoftnet(); +#ifdef MAC + mac_bpfdesc_create_mbuf(d, m); +#endif error = (*ifp->if_output)(ifp, m, (struct sockaddr *)&dst, (struct rtentry *)0); splx(s); @@ -1129,9 +1143,17 @@ bpf_tap(caddr_t arg, u_char *pkt, u_int pktlen, u_int direction) else slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen); if (slen != 0) { +#ifdef MAC + if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0) { + bpf_catchpacket(d, pkt, pktlen, slen, bcopy); + if (d->bd_fildrop) + drop++; + } +#else bpf_catchpacket(d, pkt, pktlen, slen, bcopy); if (d->bd_fildrop) drop++; +#endif } } @@ -1191,9 +1213,18 @@ bpf_mtap(caddr_t arg, struct mbuf *m, u_int direction) if (slen == 0) continue; +#ifdef MAC + if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0) { + bpf_catchpacket(d, (u_char *)m, pktlen, slen, + bpf_mcopy); + if (d->bd_fildrop) + m->m_flags |= M_FILDROP; + } +#else bpf_catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy); if (d->bd_fildrop) m->m_flags |= M_FILDROP; +#endif } } diff --git a/sys/net/bpfdesc.h b/sys/net/bpfdesc.h index 65b1851..2fb2852 100644 --- a/sys/net/bpfdesc.h +++ b/sys/net/bpfdesc.h @@ -81,6 +81,9 @@ struct bpf_d { int bd_hdrcmplt; /* false to fill in src lladdr automatically */ int bd_async; /* non-zero if packet reception should generate signal */ int bd_sig; /* signal to send upon packet reception */ +#ifdef MAC + struct label *bd_label; /* MAC label for descriptor */ +#endif pid_t bd_pgid; /* process or group id for signal */ uid_t bd_siguid; /* uid for process that set pgid */ uid_t bd_sigeuid; /* euid for process that set pgid */ diff --git a/sys/net/bsd-comp.c b/sys/net/bsd-comp.c index 0239577..53eb72d 100644 --- a/sys/net/bsd-comp.c +++ b/sys/net/bsd-comp.c @@ -53,6 +53,10 @@ #define PACKETPTR struct mbuf * #include +#ifdef MAC +#include +#endif + #if DO_BSD_COMPRESS /* * PPP "BSD compress" compression @@ -881,6 +885,10 @@ bsd_decompress(state, cmp, dmpp) wptr = mtod(dmp, u_char *); space = M_TRAILINGSPACE(dmp) - PPP_HDRLEN + 1; +#ifdef MAC + mac_mbuf_copy(cmp, dmp); +#endif + /* * Fill in the ppp header, but not the last byte of the protocol * (that comes from the decompressed data). diff --git a/sys/net/if.c b/sys/net/if.c index a398e52..7047a2b 100644 --- a/sys/net/if.c +++ b/sys/net/if.c @@ -125,6 +125,10 @@ #include #endif +#ifdef MAC +#include +#endif + void if_attachsetup(struct ifnet *); void if_attachdomain1(struct ifnet *); void if_attach_common(struct ifnet *); @@ -466,6 +470,12 @@ if_attach_common(struct ifnet *ifp) if (ifp->if_detachhooks == NULL) panic("if_attach_common: malloc"); TAILQ_INIT(ifp->if_detachhooks); + +#ifdef MAC + /* XXX PM: What about cloned interfaces? */ + mac_ifnet_init(ifp); + mac_ifnet_create(ifp); +#endif } void @@ -569,6 +579,11 @@ if_detach(struct ifnet *ifp) pfi_detach_ifnet(ifp); #endif +#ifdef MAC + /* XXX PM: What about cloned interfaces? */ + mac_ifnet_destroy(ifp); +#endif + /* * remove packets came from ifp, from software interrupt queues. * net/netisr_dispatch.h is not usable, as some of them use @@ -1262,6 +1277,12 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) ifr->ifr_flags = ifp->if_xflags; break; +#ifdef MAC + case SIOCGIFMAC: + error = mac_ifnet_ioctl_get(p->p_ucred, ifr, ifp); + break; +#endif + case SIOCGIFMETRIC: ifr->ifr_metric = ifp->if_metric; break; @@ -1315,6 +1336,12 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) rt_ifmsg(ifp); break; +#ifdef MAC + case SIOCSIFMAC: + error = mac_ifnet_ioctl_set(p->p_ucred, ifr, ifp); + break; +#endif + case SIOCSIFMETRIC: if ((error = suser(p, 0)) != 0) return (error); diff --git a/sys/net/if.h b/sys/net/if.h index 312150c..5304702 100644 --- a/sys/net/if.h +++ b/sys/net/if.h @@ -237,6 +237,10 @@ struct ifnet { /* and the entries */ struct ifaltq if_snd; /* output queue (includes altq) */ struct sockaddr_dl *if_sadl; /* pointer to our sockaddr_dl */ +#if MAC + struct label *if_label; /* interface MAC label */ +#endif + void *if_afdata[AF_MAX]; }; #define if_mtu if_data.ifi_mtu diff --git a/sys/net/if_atmsubr.c b/sys/net/if_atmsubr.c index 0afa178..63015fb 100644 --- a/sys/net/if_atmsubr.c +++ b/sys/net/if_atmsubr.c @@ -110,6 +110,10 @@ #include #endif /* INET6 */ +#ifdef MAC +#include +#endif + #define senderr(e) { error = (e); goto bad;} /* @@ -144,7 +148,11 @@ atm_output(ifp, m0, dst, rt0) if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) senderr(ENETDOWN); - +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m0); + if (error) + senderr(error); +#endif /* * check route */ @@ -269,6 +277,9 @@ atm_input(ifp, ah, m, rxhand) m_freem(m); return; } +#ifdef MAC + mac_ifnet_create_mbuf(ifp, m); +#endif ifp->if_ibytes += m->m_pkthdr.len; if (rxhand) { diff --git a/sys/net/if_ethersubr.c b/sys/net/if_ethersubr.c index ed6addc..282c00a 100644 --- a/sys/net/if_ethersubr.c +++ b/sys/net/if_ethersubr.c @@ -160,6 +160,10 @@ extern u_char aarp_org_code[ 3 ]; #include #endif /* MPLS */ +#ifdef MAC +#include +#endif + u_char etherbroadcastaddr[ETHER_ADDR_LEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; #define senderr(e) { error = (e); goto bad;} @@ -243,7 +247,11 @@ ether_output(ifp0, m0, dst, rt0) if (ifp->if_type == IFT_IEEE8023ADLAG) senderr(EBUSY); #endif - +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m0); + if (error) + senderr(error); +#endif #if NCARP > 0 if (ifp->if_type == IFT_CARP) { struct ifaddr *ifa; @@ -605,6 +613,10 @@ ether_input(ifp0, eh, m) #endif } +#ifdef MAC + mac_ifnet_create_mbuf(ifp, m); +#endif + ifp->if_ibytes += m->m_pkthdr.len + sizeof(*eh); #if NTRUNK > 0 if (ifp != ifp0) diff --git a/sys/net/if_fddisubr.c b/sys/net/if_fddisubr.c index 3b9370a..458ef26 100644 --- a/sys/net/if_fddisubr.c +++ b/sys/net/if_fddisubr.c @@ -116,6 +116,10 @@ #include #endif +#ifdef MAC +#include +#endif + #define senderr(e) { error = (e); goto bad;} /* @@ -148,6 +152,12 @@ fddi_output(ifp0, m0, dst, rt0) short mflags; struct ifnet *ifp = ifp0; +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m0); + if (error) + senderr(error); +#endif + #if NCARP > 0 if (ifp->if_type == IFT_CARP) { struct ifaddr *ifa; @@ -383,6 +393,9 @@ fddi_input(ifp, fh, m) m_freem(m); return; } +#ifdef MAC + mac_ifnet_create_mbuf(ifp, m); +#endif ifp->if_ibytes += m->m_pkthdr.len + sizeof (*fh); if (bcmp((caddr_t)fddibroadcastaddr, (caddr_t)fh->fddi_dhost, sizeof(fddibroadcastaddr)) == 0) diff --git a/sys/net/if_gif.c b/sys/net/if_gif.c index c88f292..1ff6504 100644 --- a/sys/net/if_gif.c +++ b/sys/net/if_gif.c @@ -61,6 +61,10 @@ #include +#ifdef MAC +#include +#endif + #include "bpfilter.h" #include "bridge.h" @@ -268,6 +272,14 @@ gif_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst, goto end; } +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m); + if (error) { + m_freem(m); + goto end; + } +#endif + switch (sc->gif_psrc->sa_family) { #ifdef INET case AF_INET: diff --git a/sys/net/if_ppp.c b/sys/net/if_ppp.c index cfa3e4a..6561368 100644 --- a/sys/net/if_ppp.c +++ b/sys/net/if_ppp.c @@ -157,6 +157,10 @@ #include #endif +#ifdef MAC +#include +#endif + static int pppsioctl(struct ifnet *, u_long, caddr_t); static void ppp_requeue(struct ppp_softc *); static void ppp_ccp(struct ppp_softc *, struct mbuf *m, int rcvd); @@ -727,6 +731,12 @@ pppoutput(ifp, m0, dst, rtp) goto bad; } +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m0); + if (error) + goto bad; +#endif + /* * Compute PPP header. */ @@ -1124,6 +1134,9 @@ pppintr() splx(s2); if (m == NULL) break; +#ifdef MAC + mac_ifnet_create_mbuf(&sc->sc_if, m); +#endif ppp_inproc(sc, m); } } @@ -1404,6 +1417,9 @@ ppp_inproc(sc, m) goto bad; /* lose if big headers and no clusters */ } } +#ifdef MAC + mac_mbuf_copy(m, mp); +#endif if (m->m_flags & M_PKTHDR) M_MOVE_HDR(mp, m); cp = mtod(mp, u_char *); @@ -1457,6 +1473,9 @@ ppp_inproc(sc, m) if (ilen <= MHLEN && M_IS_CLUSTER(m)) { MGETHDR(mp, M_DONTWAIT, MT_DATA); if (mp != NULL) { +#ifdef MAC + mac_mbuf_copy(m, mp); +#endif m_copydata(m, 0, ilen, mtod(mp, caddr_t)); m_freem(m); m = mp; diff --git a/sys/net/if_tun.c b/sys/net/if_tun.c index 272b35b..c46bdfc 100644 --- a/sys/net/if_tun.c +++ b/sys/net/if_tun.c @@ -87,6 +87,10 @@ #include +#ifdef MAC +#include +#endif + struct tun_softc { struct arpcom arpcom; /* ethernet common data */ struct selinfo tun_rsel; /* read select */ @@ -569,6 +573,14 @@ tun_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst, return (EHOSTDOWN); } +#ifdef MAC + error = mac_ifnet_check_transmit(ifp, m0); + if (error) { + m_freem(m0); + return (error); + } +#endif + if (tp->tun_flags & TUN_LAYER2) /* call ether_output and that will call tunstart at the end */ return (ether_output(ifp, m0, dst, rt)); @@ -941,6 +953,9 @@ tunwrite(dev_t dev, struct uio *uio, int ioflag) ifp->if_ipackets++; ifp->if_ibytes += top->m_pkthdr.len; splx(s); +#ifdef MAC + mac_ifnet_create_mbuf(ifp, m); +#endif return (error); } diff --git a/sys/net/pf.c b/sys/net/pf.c index 9535446..92df97e 100644 --- a/sys/net/pf.c +++ b/sys/net/pf.c @@ -92,6 +92,9 @@ #include #endif /* INET6 */ +#ifdef MAC +#include +#endif #define DPFPRINTF(n, x) if (pf_status.debug >= (n)) printf x @@ -149,7 +152,12 @@ void pf_change_icmp(struct pf_addr *, u_int16_t *, struct pf_addr *, struct pf_addr *, u_int16_t, u_int16_t *, u_int16_t *, u_int16_t *, u_int16_t *, u_int8_t, sa_family_t); +#ifdef MAC +void pf_send_tcp(struct mbuf *, const struct pf_rule *, + sa_family_t, +#else void pf_send_tcp(const struct pf_rule *, sa_family_t, +#endif const struct pf_addr *, const struct pf_addr *, u_int16_t, u_int16_t, u_int32_t, u_int32_t, u_int8_t, u_int16_t, u_int16_t, u_int8_t, int, @@ -1101,7 +1109,11 @@ pf_unlink_state(struct pf_state *cur) if (cur->src.state == PF_TCPS_PROXY_DST) { /* XXX wire key the right one? */ +#ifdef MAC + pf_send_tcp(NULL, cur->rule.ptr, cur->key[PF_SK_WIRE]->af, +#else pf_send_tcp(cur->rule.ptr, cur->key[PF_SK_WIRE]->af, +#endif &cur->key[PF_SK_WIRE]->addr[1], &cur->key[PF_SK_WIRE]->addr[0], cur->key[PF_SK_WIRE]->port[1], @@ -1878,7 +1890,11 @@ pf_modulate_sack(struct mbuf *m, int off, struct pf_pdesc *pd, } void +#ifdef MAC +pf_send_tcp(struct mbuf *replyto, const struct pf_rule *r, sa_family_t af, +#else pf_send_tcp(const struct pf_rule *r, sa_family_t af, +#endif const struct pf_addr *saddr, const struct pf_addr *daddr, u_int16_t sport, u_int16_t dport, u_int32_t seq, u_int32_t ack, u_int8_t flags, u_int16_t win, u_int16_t mss, u_int8_t ttl, int tag, @@ -1918,6 +1934,14 @@ pf_send_tcp(const struct pf_rule *r, sa_family_t af, m = m_gethdr(M_DONTWAIT, MT_HEADER); if (m == NULL) return; + +#ifdef MAC + if (replyto) + mac_netinet_firewall_reply(replyto, m); + else + mac_netinet_firewall_send(m); +#endif + if (tag) m->m_pkthdr.pf.flags |= PF_TAG_GENERATED; m->m_pkthdr.pf.tag = rtag; @@ -3030,7 +3054,11 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, ack++; if (th->th_flags & TH_FIN) ack++; +#ifdef MAC + pf_send_tcp(m, r, af, pd->dst, +#else pf_send_tcp(r, af, pd->dst, +#endif pd->src, th->th_dport, th->th_sport, ntohl(th->th_ack), ack, TH_RST|TH_ACK, 0, 0, r->return_ttl, 1, 0, m->m_pkthdr.rdomain, @@ -3293,7 +3321,11 @@ pf_create_state(struct pf_rule *r, struct pf_rule *nr, struct pf_rule *a, mss = pf_calc_mss(pd->src, pd->af, mss); mss = pf_calc_mss(pd->dst, pd->af, mss); s->src.mss = mss; +#ifdef MAC + pf_send_tcp(NULL, r, pd->af, pd->dst, pd->src, th->th_dport, +#else pf_send_tcp(r, pd->af, pd->dst, pd->src, th->th_dport, +#endif th->th_sport, s->src.seqhi, ntohl(th->th_seq) + 1, TH_SYN|TH_ACK, 0, s->src.mss, 0, 1, 0, /* XXX */ 0, NULL, NULL, act->rtableid); REASON_SET(&reason, PFRES_SYNPROXY); @@ -3703,7 +3735,11 @@ pf_tcp_track_full(struct pf_state_peer *src, struct pf_state_peer *dst, (*state)->src.state == TCPS_SYN_SENT) { /* Send RST for state mismatches during handshake */ if (!(th->th_flags & TH_RST)) +#ifdef MAC + pf_send_tcp(m, (*state)->rule.ptr, pd->af, +#else pf_send_tcp((*state)->rule.ptr, pd->af, +#endif pd->dst, pd->src, th->th_dport, th->th_sport, ntohl(th->th_ack), 0, TH_RST, 0, 0, @@ -3857,7 +3893,11 @@ pf_test_state_tcp(struct pf_state **state, int direction, struct pfi_kif *kif, REASON_SET(reason, PFRES_SYNPROXY); return (PF_DROP); } +#ifdef MAC + pf_send_tcp(NULL, (*state)->rule.ptr, pd->af, pd->dst, +#else pf_send_tcp((*state)->rule.ptr, pd->af, pd->dst, +#endif pd->src, th->th_dport, th->th_sport, (*state)->src.seqhi, ntohl(th->th_seq) + 1, TH_SYN|TH_ACK, 0, (*state)->src.mss, 0, 1, @@ -3887,7 +3927,11 @@ pf_test_state_tcp(struct pf_state **state, int direction, struct pfi_kif *kif, (*state)->src.max_win = MAX(ntohs(th->th_win), 1); if ((*state)->dst.seqhi == 1) (*state)->dst.seqhi = htonl(arc4random()); +#ifdef MAC + pf_send_tcp(NULL, (*state)->rule.ptr, pd->af, +#else pf_send_tcp((*state)->rule.ptr, pd->af, +#endif &sk->addr[pd->sidx], &sk->addr[pd->didx], sk->port[pd->sidx], sk->port[pd->didx], (*state)->dst.seqhi, 0, TH_SYN, 0, @@ -3903,13 +3947,21 @@ pf_test_state_tcp(struct pf_state **state, int direction, struct pfi_kif *kif, } else { (*state)->dst.max_win = MAX(ntohs(th->th_win), 1); (*state)->dst.seqlo = ntohl(th->th_seq); +#ifdef MAC + pf_send_tcp(NULL, (*state)->rule.ptr, pd->af, pd->dst, +#else pf_send_tcp((*state)->rule.ptr, pd->af, pd->dst, +#endif pd->src, th->th_dport, th->th_sport, ntohl(th->th_ack), ntohl(th->th_seq) + 1, TH_ACK, (*state)->src.max_win, 0, 0, 0, (*state)->tag, /* XXX */ 0, NULL, NULL, (*state)->rtableid); +#ifdef MAC + pf_send_tcp(NULL, (*state)->rule.ptr, pd->af, +#else pf_send_tcp((*state)->rule.ptr, pd->af, +#endif &sk->addr[pd->sidx], &sk->addr[pd->didx], sk->port[pd->sidx], sk->port[pd->didx], (*state)->src.seqhi + 1, (*state)->src.seqlo + 1, diff --git a/sys/netatalk/ddp_input.c b/sys/netatalk/ddp_input.c index a7f9a94..57d1164 100644 --- a/sys/netatalk/ddp_input.c +++ b/sys/netatalk/ddp_input.c @@ -1,4 +1,4 @@ -/* $OpenBSD: brad $ */ +/* $OpenBSD: ddp_input.c,v 1.4 2006/03/04 22:40:16 brad Exp $ */ /* * Copyright (c) 1990,1994 Regents of The University of Michigan. diff --git a/sys/netinet/if_ether.c b/sys/netinet/if_ether.c index 09ee913..be23f79 100644 --- a/sys/netinet/if_ether.c +++ b/sys/netinet/if_ether.c @@ -64,6 +64,10 @@ #include #endif +#ifdef MAC +#include +#endif + #define SIN(s) ((struct sockaddr_in *)s) #define SDL(s) ((struct sockaddr_dl *)s) #define SRP(s) ((struct sockaddr_inarp *)s) @@ -359,6 +363,9 @@ arprequest(ifp, sip, tip, enaddr) bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa)); sa.sa_family = pseudo_AF_HDRCMPLT; sa.sa_len = sizeof(sa); +#ifdef MAC + mac_netinet_arp_send(ifp, m); +#endif (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0); } diff --git a/sys/netinet/igmp.c b/sys/netinet/igmp.c index f3fddf9..8cb1320 100644 --- a/sys/netinet/igmp.c +++ b/sys/netinet/igmp.c @@ -95,6 +95,10 @@ #include +#ifdef MAC +#include +#endif + #define IP_MULTICASTOPTS 0 int *igmpctl_vars[IGMPCTL_MAXID] = IGMPCTL_VARS; @@ -620,7 +624,9 @@ igmp_sendpkt(inm, type, addr) #else imo.imo_multicast_loop = 0; #endif /* MROUTING */ - +#ifdef MAC + mac_netinet_igmp_send(inm->inm_ia->ia_ifp, m); +#endif ip_output(m, (struct mbuf *)0, (struct route *)0, IP_MULTICASTOPTS, &imo, (void *)NULL); diff --git a/sys/netinet/in_pcb.c b/sys/netinet/in_pcb.c index d5d4e9b..b6f2e22 100644 --- a/sys/netinet/in_pcb.c +++ b/sys/netinet/in_pcb.c @@ -102,6 +102,10 @@ #include #endif /* IPSEC */ +#ifdef MAC +#include +#endif + struct in_addr zeroin_addr; extern int ipsec_auth_default_level; @@ -182,6 +186,9 @@ in_pcballoc(so, v) struct inpcbtable *table = v; struct inpcb *inp; int s; +#ifdef MAC + int error; +#endif if (inpcb_pool_initialized == 0) { pool_init(&inpcb_pool, sizeof(struct inpcb), 0, 0, 0, @@ -198,6 +205,13 @@ in_pcballoc(so, v) inp->inp_seclevel[SL_ESP_TRANS] = ipsec_esp_trans_default_level; inp->inp_seclevel[SL_ESP_NETWORK] = ipsec_esp_network_default_level; inp->inp_seclevel[SL_IPCOMP] = ipsec_ipcomp_default_level; +#ifdef MAC + error = mac_inpcb_init(inp, M_NOWAIT); + if (error) { + pool_put(&inpcb_pool, inp); + return (error); + } +#endif s = splnet(); CIRCLEQ_INSERT_HEAD(&table->inpt_queue, inp, inp_queue); LIST_INSERT_HEAD(INPCBLHASH(table, inp->inp_lport, inp->inp_rdomain), @@ -205,6 +219,10 @@ in_pcballoc(so, v) LIST_INSERT_HEAD(INPCBHASH(table, &inp->inp_faddr, inp->inp_fport, &inp->inp_laddr, inp->inp_lport, inp->inp_rdomain), inp, inp_hash); splx(s); +#ifdef MAC + /* XXX PM: No locking done on the socket. */ + mac_inpcb_create(so, inp); +#endif so->so_pcb = inp; inp->inp_hops = -1; @@ -477,6 +495,10 @@ in_pcbdetach(v) struct socket *so = inp->inp_socket; int s; +#ifdef MAC + mac_inpcb_destroy(inp); +#endif + so->so_pcb = 0; sofree(so); if (inp->inp_options) @@ -1140,3 +1162,28 @@ in6_pcblookup_listen(struct inpcbtable *table, struct in6_addr *laddr, return (inp); } #endif /* INET6 */ + +/* + * A set label operation has occurred at the socket layer, propagate the + * label change into the in_pcb for the socket. + */ +void +in_pcbsosetlabel(struct socket *so) +{ +#ifdef MAC + struct inpcb *inp; + + inp = sotoinpcb(so); + KASSERT(inp != NULL); + +#if 0 + INP_WLOCK(inp); + SOCK_LOCK(so); +#endif + mac_inpcb_sosetlabel(so, inp); +#if 0 + SOCK_UNLOCK(so); + INP_WUNLOCK(inp); +#endif +#endif /* MAC */ +} diff --git a/sys/netinet/in_pcb.h b/sys/netinet/in_pcb.h index a2d4aec..320b472 100644 --- a/sys/netinet/in_pcb.h +++ b/sys/netinet/in_pcb.h @@ -147,6 +147,7 @@ struct inpcb { struct icmp6_filter *inp_icmp6filt; void *inp_pf_sk; u_int inp_rdomain; + struct label *inp_label; /* MAC label */ }; struct inpcbtable { @@ -282,6 +283,7 @@ extern struct sockaddr_in *in_selectsrc(struct sockaddr_in *, struct route *, int, struct ip_moptions *, int *, u_int); struct rtentry * in_pcbrtentry(struct inpcb *); +void in_pcbsosetlabel(struct socket *); /* INET6 stuff */ int in6_pcbnotify(struct inpcbtable *, struct sockaddr *, diff --git a/sys/netinet/ip_icmp.c b/sys/netinet/ip_icmp.c index 51b1388..af2253a 100644 --- a/sys/netinet/ip_icmp.c +++ b/sys/netinet/ip_icmp.c @@ -98,6 +98,10 @@ #include #endif +#ifdef MAC +#include +#endif + /* * ICMP routines: error generation, receive packet processing, and * routines to turnaround packets back to the originator, and @@ -190,6 +194,10 @@ icmp_do_error(struct mbuf *n, int type, int code, n_long dest, int destmtu) mblen += m->m_len; icmplen = min(mblen, icmplen); +#ifdef MAC + mac_netinet_icmp_reply(n, m); +#endif + /* * As we are not required to return everything we have, * we return whatever we can return at ease. @@ -700,6 +708,10 @@ icmp_reflect(struct mbuf *m) RTFREE(ro.ro_rt); } +#ifdef MAC + mac_netinet_icmp_replyinplace(m); +#endif + t = ia->ia_addr.sin_addr; ip->ip_src = t; ip->ip_ttl = MAXTTL; diff --git a/sys/netinet/ip_input.c b/sys/netinet/ip_input.c index f7521cd..0a8382d 100644 --- a/sys/netinet/ip_input.c +++ b/sys/netinet/ip_input.c @@ -76,6 +76,10 @@ #include #endif +#ifdef MAC +#include +#endif + #define IPMTUDISCTIMEOUT (10 * 60) /* as per RFC 1191 */ struct ipqhead ipq; @@ -538,6 +542,9 @@ ours: if (ip->ip_id == fp->ipq_id && ip->ip_src.s_addr == fp->ipq_src.s_addr && ip->ip_dst.s_addr == fp->ipq_dst.s_addr && +#ifdef MAC + mac_ipq_match(m, fp) && +#endif ip->ip_p == fp->ipq_p) goto found; fp = 0; @@ -744,15 +751,26 @@ ip_reass(ipqe, fp) fp = pool_get(&ipq_pool, PR_NOWAIT); if (fp == NULL) goto dropfrag; - LIST_INSERT_HEAD(&ipq, fp, ipq_q); fp->ipq_ttl = IPFRAGTTL; fp->ipq_p = ipqe->ipqe_ip->ip_p; fp->ipq_id = ipqe->ipqe_ip->ip_id; LIST_INIT(&fp->ipq_fragq); fp->ipq_src = ipqe->ipqe_ip->ip_src; fp->ipq_dst = ipqe->ipqe_ip->ip_dst; +#ifdef MAC + if (mac_ipq_init(fp, M_NOWAIT)) { + pool_put(&ipq_pool, fp); + goto dropfrag; + } + mac_ipq_create(m, fp); +#endif + LIST_INSERT_HEAD(&ipq, fp, ipq_q); p = NULL; goto insert; +#ifdef MAC + } else { + mac_ipq_update(m, fp); +#endif } /* @@ -868,6 +886,11 @@ insert: m_cat(m, t); } +#ifdef MAC + mac_ipq_reassemble(fp, m); + mac_ipq_destroy(fp); +#endif + /* * Create header for new ip packet by * modifying header of first packet; diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 703b40e..86008a3 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -64,6 +64,10 @@ #include #endif +#ifdef MAC +#include +#endif + #ifdef IPSEC #ifdef ENCDEBUG #define DPRINTF(x) do { if (encdebug) printf x ; } while (0) @@ -887,6 +891,9 @@ ip_fragment(struct mbuf *m, struct ifnet *ifp, u_long mtu) ipstat.ips_outhwcsum++; } else mhip->ip_sum = in_cksum(m, mhlen); +#ifdef MAC + mac_netinet_fragment(m0, m); +#endif ipstat.ips_ofragments++; fragments++; } @@ -959,6 +966,9 @@ ip_insertoptions(m, opt, phlen) if (n == 0) return (m); M_MOVE_HDR(n, m); +#ifdef MAC + mac_mbuf_copy(m, n); +#endif n->m_pkthdr.len += optlen; m->m_len -= sizeof(struct ip); m->m_data += sizeof(struct ip); diff --git a/sys/netinet/ip_var.h b/sys/netinet/ip_var.h index aaba263..ba58855 100644 --- a/sys/netinet/ip_var.h +++ b/sys/netinet/ip_var.h @@ -72,6 +72,7 @@ struct ipq { u_int16_t ipq_id; /* sequence id for reassembly */ struct ipqehead ipq_fragq; /* to ip fragment queue */ struct in_addr ipq_src, ipq_dst; + struct label *ipq_label; /* MAC label */ }; /* diff --git a/sys/netinet/raw_ip.c b/sys/netinet/raw_ip.c index a6411b7..6792021 100644 --- a/sys/netinet/raw_ip.c +++ b/sys/netinet/raw_ip.c @@ -88,6 +88,10 @@ #include #include +#ifdef MAC +#include +#endif + #include "pf.h" struct inpcbtable rawcbtable; @@ -158,6 +162,13 @@ rip_input(struct mbuf *m, ...) struct mbuf *n; if ((n = m_copy(m, 0, (int)M_COPYALL)) != NULL) { +#ifdef MAC + if (mac_inpcb_check_deliver(last, n)) { + last = inp; + m_freem(n); + continue; + } +#endif if (last->inp_flags & INP_CONTROLOPTS || last->inp_socket->so_options & SO_TIMESTAMP) ip_savecontrol(last, &opts, ip, n); @@ -175,6 +186,10 @@ rip_input(struct mbuf *m, ...) last = inp; } if (last) { +#ifdef MAC + if (mac_inpcb_check_deliver(last, m)) + return; +#endif if (last->inp_flags & INP_CONTROLOPTS || last->inp_socket->so_options & SO_TIMESTAMP) ip_savecontrol(last, &opts, ip, m); @@ -274,6 +289,9 @@ rip_output(struct mbuf *m, ...) /* force routing domain */ m->m_pkthdr.rdomain = inp->inp_rdomain; +#ifdef MAC + mac_inpcb_create_mbuf(inp, m); +#endif return (ip_output(m, inp->inp_options, &inp->inp_route, flags, inp->inp_moptions, inp)); } @@ -512,7 +530,11 @@ rip_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam, case PRU_PEERADDR: in_setpeeraddr(inp, nam); break; - +#ifdef MAC + case PRU_SOSETLABEL: + in_pcbsosetlabel(so); + break; +#endif default: panic("rip_usrreq"); } diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c index 3573645..6281ce3 100644 --- a/sys/netinet/tcp_input.c +++ b/sys/netinet/tcp_input.c @@ -110,6 +110,10 @@ int tcp_mss_adv(struct ifnet *, int); #include #include +#ifdef MAC +#include +#endif + struct tcpipv6hdr tcp_saveti6; /* for the packet header length in the mbuf */ @@ -657,6 +661,11 @@ findpcb: if (tp->t_state == TCPS_CLOSED) goto drop; +#ifdef MAC + if (mac_inpcb_check_deliver(inp, m)) + goto drop; +#endif + /* Unscale the window into a 32-bit value. */ if ((tiflags & TH_SYN) == 0) tiwin = th->th_win << tp->snd_scale; @@ -1239,6 +1248,9 @@ after_listen: if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) { tcpstat.tcps_connects++; soisconnected(so); +#ifdef MAC + mac_socketpeer_set_from_mbuf(m, so); +#endif tp->t_state = TCPS_ESTABLISHED; TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle); /* Do window scaling on this connection? */ @@ -3520,7 +3532,9 @@ syn_cache_reaper(void *arg) { struct syn_cache *sc = arg; int s; - +#ifdef MAC + mac_syncache_destroy(&sc->sc_label); +#endif s = splsoftnet(); pool_put(&syn_cache_pool, (sc)); splx(s); @@ -3655,6 +3669,10 @@ syn_cache_get(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, if (so == NULL) goto resetandabort; +#ifdef MAC + mac_socketpeer_set_from_mbuf(m, so); +#endif + inp = sotoinpcb(oso); #ifdef IPSEC /* @@ -3939,9 +3957,19 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, struct syn_cache *sc; struct syn_cache_head *scp; struct mbuf *ipopts; +#ifdef MAC + struct label *maclabel; +#endif tp = sototcpcb(so); +#ifdef MAC + if (mac_syncache_init(&maclabel)) + return (0); + else + mac_syncache_create(maclabel, tp->t_inpcb); +#endif + /* * RFC1122 4.2.3.10, p. 104: discard bcast/mcast SYN * @@ -3970,8 +3998,12 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, tb.t_flags |= TF_SIGNATURE; #endif tb.t_state = TCPS_LISTEN; - if (tcp_dooptions(&tb, optp, optlen, th, m, iphlen, oi)) + if (tcp_dooptions(&tb, optp, optlen, th, m, iphlen, oi)) { +#ifdef MAC + mac_syncache_destroy(&maclabel); +#endif return (0); + } } else tb.t_flags = 0; @@ -4004,6 +4036,14 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, (void) m_free(sc->sc_ipopts); sc->sc_ipopts = ipopts; } +#ifdef MAC + /* + * Since we have already unconditionally allocated label + * storage, free it up. The syncache entry will already + * have an initialized label we can use. + */ + mac_syncache_destroy(&maclabel); +#endif sc->sc_timestamp = tb.ts_recent; if (syn_cache_respond(sc, m) == 0) { tcpstat.tcps_sndacks++; @@ -4016,6 +4056,9 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, if (sc == NULL) { if (ipopts) (void) m_free(ipopts); +#ifdef MAC + mac_syncache_destroy(&maclabel); +#endif return (0); } @@ -4030,6 +4073,9 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, sc->sc_flags = 0; sc->sc_ipopts = ipopts; sc->sc_irs = th->th_seq; +#ifdef MAC + sc->sc_label = maclabel; +#endif sc->sc_iss = issp ? *issp : arc4random(); sc->sc_peermaxseg = oi->maxseg; @@ -4074,6 +4120,9 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th, if (tb.t_flags & TF_SIGNATURE) sc->sc_flags |= SCF_SIGNATURE; #endif +#ifdef MAC + mac_syncache_create(sc->sc_label, tp->t_inpcb); +#endif sc->sc_tp = tp; if (syn_cache_respond(sc, m) == 0) { syn_cache_insert(sc, tp); @@ -4150,6 +4199,10 @@ syn_cache_respond(struct syn_cache *sc, struct mbuf *m) if (m == NULL) return (ENOBUFS); +#ifdef MAC + mac_syncache_create_mbuf(sc->sc_label, m); +#endif + /* Fixup the mbuf. */ m->m_data += max_linkhdr; m->m_len = m->m_pkthdr.len = tlen; diff --git a/sys/netinet/tcp_output.c b/sys/netinet/tcp_output.c index 3be34e2..579f681 100644 --- a/sys/netinet/tcp_output.c +++ b/sys/netinet/tcp_output.c @@ -98,6 +98,10 @@ #include #endif /* INET6 */ +#ifdef MAC +#include +#endif + #ifdef notyet extern struct mbuf *m_copypack(); #endif @@ -762,6 +766,10 @@ send: m->m_pkthdr.rcvif = (struct ifnet *)0; m->m_pkthdr.len = hdrlen + len; +#ifdef MAC + mac_inpcb_create_mbuf(tp->t_inpcb, m); +#endif + if (!tp->t_template) panic("tcp_output"); #ifdef DIAGNOSTIC diff --git a/sys/netinet/tcp_subr.c b/sys/netinet/tcp_subr.c index 815804e..0397531 100644 --- a/sys/netinet/tcp_subr.c +++ b/sys/netinet/tcp_subr.c @@ -102,6 +102,10 @@ #include +#ifdef MAC +#include +#endif + /* patchable/settable parameters for tcp */ int tcp_mssdflt = TCP_MSS; int tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ; @@ -397,6 +401,21 @@ tcp_respond(tp, template, th0, ack, seq, flags) m->m_len = tlen; m->m_pkthdr.len = tlen; m->m_pkthdr.rcvif = (struct ifnet *) 0; +#ifdef MAC + if (tp != NULL && tp->t_inpcb != NULL) { + /* + * Packet is associated with a socket, so allow the label of + * the response to reflect the socket label. + */ + mac_inpcb_create_mbuf(tp->t_inpcb, m); + } else { + /* + * Packet is not associated with a socket, so possibly update + * the label in place. + */ + mac_netinet_tcp_reply(m); + } +#endif th->th_seq = htonl(seq); th->th_ack = htonl(ack); th->th_x2 = 0; diff --git a/sys/netinet/tcp_usrreq.c b/sys/netinet/tcp_usrreq.c index b0f0c9e..4fb59f8 100644 --- a/sys/netinet/tcp_usrreq.c +++ b/sys/netinet/tcp_usrreq.c @@ -474,7 +474,11 @@ tcp_usrreq(so, req, m, nam, control, p) #endif in_setpeeraddr(inp, nam); break; - +#ifdef MAC + case PRU_SOSETLABEL: + in_pcbsosetlabel(so); + break; +#endif default: panic("tcp_usrreq"); } diff --git a/sys/netinet/tcp_var.h b/sys/netinet/tcp_var.h index be2751a..e9f0135 100644 --- a/sys/netinet/tcp_var.h +++ b/sys/netinet/tcp_var.h @@ -294,6 +294,7 @@ struct syn_cache { struct tcpcb *sc_tp; /* tcb for listening socket */ LIST_ENTRY(syn_cache) sc_tpq; /* list of entries by same tp */ + struct label *sc_label; /* MAC label */ }; struct syn_cache_head { diff --git a/sys/netinet/udp_usrreq.c b/sys/netinet/udp_usrreq.c index d1b6e2e..74301a6 100644 --- a/sys/netinet/udp_usrreq.c +++ b/sys/netinet/udp_usrreq.c @@ -100,6 +100,10 @@ #endif #include +#ifdef MAC +#include +#endif + extern int ip6_defhlim; #endif /* INET6 */ @@ -476,6 +480,10 @@ udp_input(struct mbuf *m, ...) struct mbuf *n; if ((n = m_copy(m, 0, M_COPYALL)) != NULL) { +#ifdef MAC + if (mac_inpcb_check_deliver(last, n)) + goto delivery_denied; +#endif #ifdef INET6 if (ip6 && (last->inp_flags & IN6P_CONTROLOPTS || @@ -503,6 +511,9 @@ udp_input(struct mbuf *m, ...) opts = NULL; } } +#ifdef MAC +delivery_denied: +#endif last = inp; /* * Don't look for additional matches if this one does @@ -527,6 +538,10 @@ udp_input(struct mbuf *m, ...) goto bad; } +#ifdef MAC + if (mac_inpcb_check_deliver(last, m)) + goto bad; +#endif #ifdef INET6 if (ip6 && (last->inp_flags & IN6P_CONTROLOPTS || last->inp_socket->so_options & SO_TIMESTAMP)) @@ -661,6 +676,10 @@ udp_input(struct mbuf *m, ...) #endif /*IPSEC */ opts = NULL; +#ifdef MAC + if (mac_inpcb_check_deliver(inp, m)) + goto bad; +#endif #ifdef INET6 if (ip6 && (inp->inp_flags & IN6P_CONTROLOPTS || inp->inp_socket->so_options & SO_TIMESTAMP)) @@ -989,6 +1008,10 @@ udp_output(struct mbuf *m, ...) ui->ui_dport = inp->inp_fport; ui->ui_ulen = ui->ui_len; +#ifdef MAC + mac_inpcb_create_mbuf(inp, m); +#endif + /* * Compute the pseudo-header checksum; defer further checksumming * until ip_output() or hardware (if it exists). @@ -1222,7 +1245,11 @@ udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *addr, case PRU_RCVD: case PRU_RCVOOB: return (EOPNOTSUPP); /* do not free mbuf's */ - +#ifdef MAC + case PRU_SOSETLABEL: + in_pcbsosetlabel(so); + break; +#endif default: panic("udp_usrreq"); } diff --git a/sys/nfs/nfs_socket.c b/sys/nfs/nfs_socket.c index 2d11691..7a1bed3 100644 --- a/sys/nfs/nfs_socket.c +++ b/sys/nfs/nfs_socket.c @@ -68,6 +68,10 @@ #include #include +#ifdef MAC +#include +#endif + /* External data, mostly RPC constants in XDR form. */ extern u_int32_t rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, rpc_auth_unix, rpc_msgaccepted, rpc_call, rpc_autherr; @@ -712,6 +716,8 @@ errout: (rep->r_flags & R_SOFTTERM)) return (EINTR); } while (error == EWOULDBLOCK); + if (!error && *mp == NULL) + error = EPIPE; len -= auio.uio_resid; } if (error) { @@ -769,8 +775,9 @@ nfs_reply(myrep) * Ignore routing errors on connectionless protocols?? */ if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) { - if (nmp->nm_so) - nmp->nm_so->so_error = 0; + if (!nmp->nm_so) + return error; + nmp->nm_so->so_error = 0; continue; } return (error); @@ -1585,6 +1592,9 @@ nfs_getreq(nd, nfsd, has_header) nd->nd_cr.cr_ref = 1; nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++); nd->nd_cr.cr_gid = fxdr_unsigned(gid_t, *tl++); +#ifdef MAC + mac_cred_associate_nfsd(&nd->nd_cr); +#endif len = fxdr_unsigned(int, *tl); if (len < 0 || len > RPCAUTH_UNIXGIDS) { m_freem(mrep); diff --git a/sys/nfs/nfs_vnops.c b/sys/nfs/nfs_vnops.c index 5f43023..85c7391 100644 --- a/sys/nfs/nfs_vnops.c +++ b/sys/nfs/nfs_vnops.c @@ -550,9 +550,9 @@ nfs_setattr(v) u_quad_t tsize = 0; /* - * Setting of flags is not supported. + * Setting of flags and marking of atimes are not supported. */ - if (vap->va_flags != VNOVAL) + if (vap->va_flags != VNOVAL || (vap->va_vaflags & VA_MARK_ATIME)) return (EOPNOTSUPP); /* @@ -1276,7 +1276,8 @@ nfsmout: nfs_cache_enter(dvp, newvp, cnp); *vpp = newvp; } - pool_put(&namei_pool, cnp->cn_pnbuf); + if (error || (cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); VTONFS(dvp)->n_flag |= NMODIFIED; if (!wccflag) NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp)); @@ -1396,7 +1397,8 @@ nfsmout: nfs_cache_enter(dvp, newvp, cnp); *ap->a_vpp = newvp; } - pool_put(&namei_pool, cnp->cn_pnbuf); + if (error || (cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); VTONFS(dvp)->n_flag |= NMODIFIED; if (!wccflag) NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp)); @@ -1466,7 +1468,8 @@ nfs_remove(v) error = 0; } else if (!np->n_sillyrename) error = nfs_sillyrename(dvp, vp, cnp); - pool_put(&namei_pool, cnp->cn_pnbuf); + if ((cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); NFS_INVALIDATE_ATTRCACHE(np); vrele(dvp); vrele(vp); @@ -1781,7 +1784,8 @@ nfs_symlink(v) nfsmout: if (newvp) vrele(newvp); - pool_put(&namei_pool, cnp->cn_pnbuf); + if (error || (cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); VTONFS(dvp)->n_flag |= NMODIFIED; if (!wccflag) NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp)); @@ -1865,7 +1869,8 @@ nfsmout: nfs_cache_enter(dvp, newvp, cnp); *ap->a_vpp = newvp; } - pool_put(&namei_pool, cnp->cn_pnbuf); + if (error || (cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); vrele(dvp); return (error); } @@ -1891,7 +1896,8 @@ nfs_rmdir(v) if (dvp == vp) { vrele(dvp); vrele(dvp); - pool_put(&namei_pool, cnp->cn_pnbuf); + if ((cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); return (EINVAL); } nfsstats.rpccnt[NFSPROC_RMDIR]++; @@ -1910,7 +1916,6 @@ nfs_rmdir(v) nfsm_wcc_data(dvp, wccflag); m_freem(mrep); nfsmout: - pool_put(&namei_pool, cnp->cn_pnbuf); VTONFS(dvp)->n_flag |= NMODIFIED; if (!wccflag) NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp)); @@ -1926,6 +1931,8 @@ nfsmout: */ if (error == ENOENT) error = 0; + if ((cnp->cn_flags & SAVESTART) == 0) + pool_put(&namei_pool, cnp->cn_pnbuf); return (error); } diff --git a/sys/security/mac/README b/sys/security/mac/README new file mode 100644 index 0000000..cbff524 --- /dev/null +++ b/sys/security/mac/README @@ -0,0 +1,431 @@ +This document holds notes and random thoughts considering the implementation of +the TrustedBSD MAC framework in OpenBSD. + +1. Locking + +Once in kernel mode, process preemption does not occur. While interrupts may be +acknowledged, no other process will be allowed to enter the kernel unless the +initial process sleeps or returns to userland. FreeBSD has the same design. +In OpenBSD, due to the biglock, the same situation happens on multiprocessor +systems. FreeBSD, on the other hand, has fine-grained locking throughout most +of the kernel. As a consequence, FreeBSD has implemented a lot of object locks +that simply do not exist in OpenBSD. + +Most of the MAC hooks are reached from a process context, and only a few are +called from interrupt context. For interrupt context calls or code dealing with +correlated data structures, proper spl(9) protection should be enforced. As for +process context calls, the biglock will protect us unless we sleep. Since +OpenBSD lacks the aforementioned object locks, the best decision then is to +avoid sleeping if possible. + +If for some reason we must sleep, then extra care should be taken with the +manipulation of kernel objects. Preferably, references should be dropped upon +sleeping and reacquired afterwards. + +Luckily enough, most of the MAC policies do not seem to sleep at all. The same +applies for the MAC layer, except when allocating resources. An easy way to +fix this is to make sure allocations of MAC labels happen simultaneously with +the allocation of the objects themselves. The TrustedBSD MAC code already does +that (probably to avoid unnecessary locking). + +1.1 The INP* locking macros used in mac_inet.c + +The INP* locking macros used in mac_inet.c are meant to protect the contents of +a 'inpcb' structure. They manipulate a rwlock(9) lock inside the structure. In +FreeBSD, as in OpenBSD, rwlock(9) locks are held by processes. + +In mac_inet.c there are two usages of INP_LOCK_ASSERT() and two usages of +INP_WLOCK_ASSERT(). The first occurrence of INP_LOCK_ASSERT() is in +mac_inpcb_create_mbuf(), and the second is commented out. + +In mac_inpcb_create_mbuf() we do a mac_mbuf_to_label(), which in turn does a +m_tag_find(). The m_tag_find() function does not sleep, and so neither does +mac_mbuf_to_label(). We then proceed to call the 'inpcb_create_mbuf' MAC hook, +which also cannot sleep. Since we can also be called from interrupt context -- +through ipintr() -- the code was changed to enforce IPL_SOFTNET. + +The first occurrence of INP_WLOCK_ASSERT() is in mac_inpcb_sosetlabel(), and +the second in mac_syncache_create(). In mac_inpcb_sosetlabel() we are always +in process context. Since the 'inpcb' label can also be accessed from interrupt +context (see above), the code was changed to be under IPL_SOFTNET. Additionally, +the 'inpcb_sosetlabel' hook must not sleep. + +The mac_syncache_create() function can be called from interrupt context -- also +through ipintr() -- so the code was changed to be under IPL_SOFTNET. Just like +the functions previously mentioned, the mac_syncache_create() function may not +sleep. + +1.2 The SOCK_LOCK* locking macros + +The SOCK_LOCK* macros are used to protect the contents of the 'sockbuf' +structure encapsulated in a 'socket' structure. They do so by manipulating a +mutex(9) lock, which provides mutual exclusion between processes. [Notice that +this behaviour is different than the one achieved by the use of the homonymous +API in OpenBSD, which provides mutual exclusion between CPUs.] + +1.2.1 SOCK_LOCK_ASSERT() + +There are 18 occurences of SOCK_LOCK_ASSERT() in the MAC code. + +1.2.1.1 mac_inpcb_sosetlabel() + +This function has been already mentioned, and a combination of a non-sleeping +MAC hook + IPL_SOFNET should be enough to avoid races. + +1.2.1.2 mac_socket_newconn() + +This function is only called by sonewconn(). The sonewconn() function, in turn, +is already called in IPL_SOFTNET, so as long as we do not sleep in the +corresponding MAC hook, we should be safe from races. + +1.2.1.3 mac_socket_relabel() + +This function is used internally by the MAC code to relabel a socket. It is +called by mac_socket_label_set() relabel a socket. The mac_socket_label_set() +function, in turn, can be called from two places: mac_setsockopt_label() and +sys___mac_set_fd(). In both cases we are in process context, and therefore we +may not sleep in the 'socket_relabel' hook. Since the socket label can also be +acessed from interrupt context, the code was changed to enforce IPL_SOFTNET. + +1.2.1.4 mac_socketpeer_set_from_mbuf() + +This function is called from tcp_input() and syn_cache_get(). Both can be +called from interrupt context, therefore IPL_SOFTNET protection was added. +Additionally, the policy MAC hook shall not sleep. + +1.2.1.5 mac_socket_create_mbuf() + +This hook is not yet implemented. + +1.2.1.6 mac_socket_check_accept() + +This function is called directly from sys_accept(), which means we are in +process context. Thus, it is important that the hooks called by this function do +not sleep. Since the socket label can also be acessed from interrupt context +(see above), the code was changed to enforce IPL_SOFTNET. + +1.2.1.7 mac_socket_check_accepted() + +This function is also called from sys_accept(), therefore the same precautions +were taken. This a local hook, and we must not sleep in it! + +1.2.1.8 mac_socket_check_bind() + +This function is called by sys_bind(). Thus, the same precautions were taken +as in mac_socket_check_accepted() and mac_socket_check_accept(). + +1.2.1.9 mac_socket_check_connect() + +This function is called by sys_connect(), therefore the same precautions were +taken. + +1.2.1.10 mac_socket_check_deliver() + +This function is only used by the 'netatalk' code, and can be called from +interrupt context. Thus, IPL_SOFTNET protection was added around it. + +1.2.1.11 mac_socket_check_listen() + +This function is called by sys_listen(), therefore the same precautions were +taken as in mac_socket_check_bind(). + +1.2.1.12 mac_socket_check_poll() + +This function is called by soo_poll(), from process context. Thus, the same +precautions were taken. + +1.2.1.13 mac_socket_check_receive() + +This function can be called from soo_read() and recvit(). In both cases we are +in process context. Therefore, the same precautions were taken. + +1.2.1.14 mac_socket_check_relabel() + +Like mac_socket_relabel(), this function is used internally by the MAC code to +relabel a socket. See the entry for mac_socket_relabel() for details. + +1.2.1.15 mac_socket_check_send() + +This function can be called from soo_write() and sendit(). In both cases we are +in process context. Therefore, the same precautions were taken as in +mac_socket_check_receive(). + +1.2.1.16 mac_socket_check_soreceive() + +This function is called from soreceive(), which means process context. Thus, +the same precautions were taken. This a local hook, and we must not sleep in it! + +1.2.1.17 mac_socket_check_stat() + +This function is called from soo_stat(), which means process context. Thus, the +same precautions were taken. + +1.2.1.18 mac_socket_check_visible() + +This hook is not implemented in OpenBSD. + +1.2.2 SOCK_LOCK() + +There are 4 occurences of SOCK_LOCK() in the MAC code. + +1.2.2.1 mac_socket_label_set() + +This function has already been discussed above. It uses SOCK_LOCK() to protect +the call to mac_socket_check_relabel(). Since mac_socket_check_relabel() already +does the necessary locking itself, no further modifications are needed. + +1.2.2.2 mac_getsockopt_label() + +This function is called from process context. It uses SOCK_LOCK() to protect +the call to mac_socket_copy_label(), which was changed to implement the +necessary IPL_SOFTNET protection. + +1.2.2.3 mac_getsockopt_peerlabel() + +This function is called from process context. It uses SOCK_LOCK() to protect +the call to mac_socket_copy_label(), which was changed to implement the +necessary IPL_SOFTNET protection. + +1.2.2.4 sys___mac_get_fd() + +This function is called from process context. It uses SOCK_LOCK() to protect +the call to mac_socket_copy_label(), which was changed to implement the +necessary IPL_SOFTNET protection. + +1.3 The MAC_IFNET* locking macros + +The MAC_IFNET* macros are used to protect the contents of a 'ifnet' structure. +They do so by manipulating a mutex(9) lock, which provides mutual exclusion +between processes. [Notice that this behaviour is different than the one +achieved by the use of the homonymous API in OpenBSD, which provides mutual +exclusion between CPUs.] + +1.3.1 MAC_IFNET_LOCK() + +There are 8 occurences of MAC_IFNET_LOCK() in the MAC code. + +1.3.1.1 mac_netinet_arp_send() + +This function can be called from interrupt context. Therefore, appropriate +IPL_SOFTNET protection was added around it. + +1.3.1.2 mac_netinet_igmp_send() + +This function can be called from interrupt context. Therefore, appropriate +IPL_SOFTNET protection was added around it. + +1.3.1.3 mac_ifnet_create() + +This function is only called from process context. However, it touches +'ifp->if_label', which can be accessed from interrupt context. Thus, appropriate +IPL_SOFTNET protection was added around it. + +1.3.1.4 mac_ifnet_create_mbuf() + +This function can be called from interrupt context. Therefore, appropriate +IPL_SOFTNET protection was added around it. + +1.3.1.5 mac_bpfdesc_check_receive() + +This function can be called from interrupt context. Moreover, it can be called +directly from a NIC driver rx interrupt. Therefore, it needs IPL_NET protection. + +1.3.1.6 mac_ifnet_check_transmit() + +This function can be called from interrupt context. Therefore, appropriate +IPL_SOFTNET protection was added around it. + +1.3.1.7 mac_ifnet_ioctl_get() + +This function is always called from process context. It uses MAC_IFNET_LOCK() +to protect the call to mac_ifnet_copy_label(). Thus, the mac_ifnet_copy_label() +function was changed to enforce proper IPL_SOFTNET protection. + +1.3.1.8 mac_ifnet_ioctl_set() + +Like mac_ifnet_ioctl_get(), this function is always called from process +context. It uses MAC_IFNET_LOCK() to protect the call to the +'ifnet_check_relabel' MAC hook. Since 'ifp->if_label' can be accessed from +interrupt context, the function was changed to enforce IPL_SOFTNET. + +1.4 The BPFD_LOCK* locking macros + +The BPFD_LOCK* macros are used to protect the contents of a 'bpf_d' structure. +The 'bpf_d' structure represents a descriptor associated with each open bpf +file. The macros manipulate a mutex(9) lock, which provides mutual exclusion +between processes. [Notice that this behaviour is different than the one +achieved by the use of the homonymous API in OpenBSD, which provides mutual +exclusion between CPUs.] Also, notice that the FreeBSD lock doesn't have +anything to do with 'bd_locked' in 'struct bpf_d'. + +1.4.1 BPFD_LOCK_ASSERT() + +There are 2 occurences of BPFD_LOCK_ASSERT() in the MAC code. + +1.4.1.1 mac_bpfdesc_create_mbuf() + +This function is already called in an appropriate interrupt priority level. + +1.4.1.2 mac_bpfdesc_check_receive() + +This function already has proper spl(9) protection due to its use of +MAC_IFNET_LOCK(). + +1.5 The PIPE_LOCK* locking macros + +The PIPE* locking macros are used to lock a container structure holding the +two 'struct pipe' endpoints of a pipe. It is implemented in FreeBSD by the +mutex(9) API, providing mutual exclusion between processes. For the record, +this lock is allowed to be recursively acquired in FreeBSD. + +In OpenBSD there is no equivalent for this particular lock. The only kind of +access coordination mechanism in the pipe code seems to be implemented by the +pipelock()/pipeunlock() functions. These functions implement mutual exclusion +manually, by rolling in a 'lock' flag and sleeping when necessary. FreeBSD has +the same mechanism. + +1.5.1 PIPE_LOCK() + +There are 2 occurences of PIPE_LOCK() in the MAC code. + +1.5.1.1 sys___mac_get_fd() + +This function is called from process context and makes use of the PIPE_LOCK() +macro to protect a call to mac_pipe_copy_label(). The mac_pipe_copy_label() +function, however, does not sleep. + +1.5.1.2 sys___mac_set_fd() + +This function is called from process context and makes use of the PIPE_LOCK() +macro to protect a call to mac_pipe_label_set(). The mac_pipe_label_set() +function, however, does not sleep. + +1.5.2 mtx_assert(&pp->pp_mtx, MA_OWNED); + +There are 7 occurrences of 'mtx_assert(&pp->pp_mtx, MA_OWNED)' in the MAC code. + +1.5.2.1 mac_pipe_check_ioctl() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.2 mac_pipe_check_poll() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.3 mac_pipe_check_read() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.4 mac_pipe_check_relabel() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.5 mac_pipe_check_stat() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.6 mac_pipe_check_write() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.5.2.7 mac_pipe_label_set() + +Here we are in process context. Since the called MAC hook does not sleep, +further locking is unnecessary. + +1.6 The PROC_LOCK* locking macros + +The PROC_LOCK* locking macros are used to protect the contents of a process +structure. They manipulate a mutex(9) lock in FreeBSD, implementing mutual +exclusion between processes. There is no equivalent for such lock in OpenBSD. + +1.6.1 PROC_LOCK() + +There are 2 occurrences of PROC_LOCK() in the MAC code. + +1.6.1.1 mac_proc_vm_revoke() + +This function is called from process context, and uses PROC_LOCK() to protect +a call to crhold(). In OpenBSD, crhold() is a macro that does not sleep. +Therefore, no further locking is necessary. + +1.6.1.2 sys___mac_set_proc() + +This function is called from process context, and uses PROC_LOCK() to protect +a call to mac_cred_check_relabel(). The mac_cred_check_relabel() function, +however, does not sleep. Therefore, no further locking is necessary. + +1.6.2 PROC_LOCK_ASSERT() + +There are 13 occurrences of PROC_LOCK_ASSERT() in the MAC code. + +1.6.2.1 mac_proc_check_debug() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.2 mac_proc_check_sched() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.3 mac_proc_check_signal() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.4 mac_proc_check_setuid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.5 mac_proc_check_seteuid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.6 mac_proc_check_setgid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.7 mac_proc_check_setegid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.8 mac_proc_check_setgroups() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.9 mac_proc_check_setreuid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.10 mac_proc_check_setregid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.11 mac_proc_check_setresuid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.12 mac_proc_check_setresgid() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. + +1.6.2.13 mac_proc_check_wait() + +All this function does is to call a MAC hook that does not sleep. Thus, no +further locking is necessary. diff --git a/sys/security/mac/mac_cred.c b/sys/security/mac/mac_cred.c new file mode 100644 index 0000000..0a06a48 --- /dev/null +++ b/sys/security/mac/mac_cred.c @@ -0,0 +1,211 @@ +/* + * Copyright (c) 1999-2002, 2008 Robert N. M. Watson + * Copyright (c) 2001 Ilmar S. Habibulin + * Copyright (c) 2001-2003 Networks Associates Technology, Inc. + * Copyright (c) 2005 Samy Al Bahra + * Copyright (c) 2006 SPARTA, Inc. + * Copyright (c) 2008 Apple Inc. + * All rights reserved. + * + * This software was developed by Robert Watson and Ilmar Habibulin for the + * TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_cred.c,v 1.1 2008/10/28 21:53:10 rwatson Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if 0 /* XXX PM: These do not exist on OpenBSD. */ +#include +#include +#include +#include +#endif + +#include +#include +#include + +struct label * +mac_cred_label_alloc(void) +{ + struct label *label; + + label = mac_labelpool_alloc(M_WAITOK); + MAC_PERFORM(cred_init_label, label); + return (label); +} + +void +mac_cred_init(struct ucred *cred) +{ + + if (mac_labeled & MPC_OBJECT_CRED) + cred->cr_label = mac_cred_label_alloc(); + else + cred->cr_label = NULL; +} + +void +mac_cred_label_free(struct label *label) +{ + + MAC_PERFORM(cred_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_cred_destroy(struct ucred *cred) +{ + + if (cred->cr_label != NULL) { + mac_cred_label_free(cred->cr_label); + cred->cr_label = NULL; + } +} + +/* + * When a thread becomes an NFS server daemon, its credential may need to be + * updated to reflect this so that policies can recognize when file system + * operations originate from the network. + * + * At some point, it would be desirable if the credential used for each NFS + * RPC could be set based on the RPC context (i.e., source system, etc) to + * provide more fine-grained access control. + */ +void +mac_cred_associate_nfsd(struct ucred *cred) +{ + + MAC_PERFORM(cred_associate_nfsd, cred); +} + +/* + * Initialize MAC label for the first kernel process, from which other kernel + * processes and threads are spawned. + */ +void +mac_cred_create_swapper(struct ucred *cred) +{ + + MAC_PERFORM(cred_create_swapper, cred); +} + +/* + * Initialize MAC label for the first userland process, from which other + * userland processes and threads are spawned. + */ +void +mac_cred_create_init(struct ucred *cred) +{ + + MAC_PERFORM(cred_create_init, cred); +} + +int +mac_cred_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen) +{ + int error; + + MAC_EXTERNALIZE(cred, label, elements, outbuf, outbuflen); + + return (error); +} + +int +mac_cred_internalize_label(struct label *label, char *string) +{ + int error; + + MAC_INTERNALIZE(cred, label, string); + + return (error); +} + +/* + * When a new process is created, its label must be initialized. Generally, + * this involves inheritence from the parent process, modulo possible deltas. + * This function allows that processing to take place. + */ +void +mac_cred_copy(struct ucred *src, struct ucred *dest) +{ + + MAC_PERFORM(cred_copy_label, src->cr_label, dest->cr_label); +} + +/* + * When the subject's label changes, it may require revocation of privilege + * to mapped objects. This can't be done on-the-fly later with a unified + * buffer cache. + */ +void +mac_cred_relabel(struct ucred *cred, struct label *newlabel) +{ + + MAC_PERFORM(cred_relabel, cred, newlabel); +} + +int +mac_cred_check_relabel(struct ucred *cred, struct label *newlabel) +{ + int error; + + MAC_CHECK(cred_check_relabel, cred, newlabel); + + return (error); +} + +int +mac_cred_check_visible(struct ucred *cr1, struct ucred *cr2) +{ + int error; + + MAC_CHECK(cred_check_visible, cr1, cr2); + + return (error); +} diff --git a/sys/security/mac/mac_framework.c b/sys/security/mac/mac_framework.c new file mode 100644 index 0000000..b35569d --- /dev/null +++ b/sys/security/mac/mac_framework.c @@ -0,0 +1,1280 @@ +/*- + * Copyright (c) 1999-2002, 2006 Robert N. M. Watson + * Copyright (c) 2001 Ilmar S. Habibulin + * Copyright (c) 2001-2005 Networks Associates Technology, Inc. + * Copyright (c) 2005-2006 SPARTA, Inc. + * All rights reserved. + * + * This software was developed by Robert Watson and Ilmar Habibulin for the + * TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + */ + +/*- + * Framework for extensible kernel access control. This file contains core + * kernel infrastructure for the TrustedBSD MAC Framework, including policy + * registration, versioning, locking, error composition operator, and system + * calls. + * + * The MAC Framework implements three programming interfaces: + * + * - The kernel MAC interface, defined in mac_framework.h, and invoked + * throughout the kernel to request security decisions, notify of security + * related events, etc. + * + * - The MAC policy module interface, defined in mac_policy.h, which is + * implemented by MAC policy modules and invoked by the MAC Framework to + * forward kernel security requests and notifications to policy modules. + * + * - The user MAC API, defined in mac.h, which allows user programs to query + * and set label state on objects. + * + * The majority of the MAC Framework implementation may be found in + * src/sys/security/mac. Sample policy modules may be found in + * src/sys/security/mac_*. + * + * $FreeBSD: src/sys/security/mac/mac_framework.c,v 1.136 2007/01/01 01:40:29 csjp Exp $; + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +/* + * XXX PM: For now, if we are compiled in, we are enabled. + */ +#ifdef MAC_TEST +#include +int mac_test_enabled = 1; +#else +int mac_test_enabled = 0; +#endif + +/* + * XXX PM: For now, if we are compiled in, we are enabled. + */ +#ifdef ANOUBIS +#include +int mac_anoubis_enabled = 1; +#else +int mac_anoubis_enabled = 0; +#endif + +#if 0 +/* + * XXX HSH: As it might be useful for development to have + * XXX HSH: LKM support I'll keep module related stuff just + * XXX HSH: commented out for now. + * XXX HSH: + * XXX HSH: I guess we should stick with the FreeBSD version as + * XXX HSH: should be compatible with their API. + */ +/* + * Declare that the kernel provides MAC support, version 3 (FreeBSD 7.x). + * This permits modules to refuse to be loaded if the necessary support isn't + * present, even if it's pre-boot. + */ +MODULE_VERSION(kernel_mac_support, MAC_VERSION); +#endif + +static unsigned int mac_version = MAC_VERSION; + +/* + * Labels consist of a indexed set of "slots", which are allocated policies + * as required. The MAC Framework maintains a bitmask of slots allocated so + * far to prevent reuse. Slots cannot be reused, as the MAC Framework + * guarantees that newly allocated slots in labels will be NULL unless + * otherwise initialized, and because we do not have a mechanism to garbage + * collect slots on policy unload. As labeled policies tend to be statically + * loaded during boot, and not frequently unloaded and reloaded, this is not + * generally an issue. + */ +#if MAC_MAX_SLOTS > 32 +#error "MAC_MAX_SLOTS too large" +#endif + +static unsigned int mac_slot_offsets_free = (1 << MAC_MAX_SLOTS) - 1; + +/* + * Add policy modules here. + */ +struct mac_policy_conf * const mac_policies[] = { +#ifdef MAC_TEST + &mac_test_mac_policy_conf, +#endif +#ifdef ANOUBIS + &mac_anoubis_alf_mac_policy_conf, + &mac_anoubis_sfs_mac_policy_conf, + &mac_anoubis_ipc_mac_policy_conf, + &mac_anoubis_test_mac_policy_conf, +#endif + 0 +}; + +void mac_init(void); +static void mac_late_init(void); +static int mac_policy_register(struct mac_policy_conf *); + +/* + * Has the kernel started generating labeled objects yet? All read/write + * access to this variable is serialized during the boot process. Following + * the end of serialization, we don't update this flag; no locking. + */ +static int mac_late = 0; + +/* + * Flag to indicate whether or not we should allocate label storage for new + * mbufs. Since most dynamic policies we currently work with don't rely on + * mbuf labeling, try to avoid paying the cost of mtag allocation unless + * specifically notified of interest. One result of this is that if a + * dynamically loaded policy requests mbuf labels, it must be able to deal + * with a NULL label being returned on any mbufs that were already in flight + * when the policy was loaded. Since the policy already has to deal with + * uninitialized labels, this probably won't be a problem. Note: currently + * no locking. Will this be a problem? + * + * In the future, we may want to allow objects to request labeling on a per- + * object type basis, rather than globally for all objects. + */ +#ifndef MAC_ALWAYS_LABEL_MBUF +int mac_labelmbufs = 0; +#endif + +#if 0 /* XXX PM: We define this in sys/malloc.h. */ +MALLOC_DEFINE(M_MACTEMP, "mactemp", "MAC temporary label storage"); +#endif + +/* + * mac_static_policy_list holds a list of policy modules that are not loaded + * while the system is "live", and cannot be unloaded. These policies can be + * invoked without holding the busy count. + * + * mac_policy_list stores the list of dynamic policies. A busy count is + * maintained for the list, stored in mac_policy_busy. The busy count is + * protected by mac_policy_mtx; the list may be modified only while the busy + * count is 0, requiring that the lock be held to prevent new references to + * the list from being acquired. For almost all operations, incrementing the + * busy count is sufficient to guarantee consistency, as the list cannot be + * modified while the busy count is elevated. For a few special operations + * involving a change to the list of active policies, the mtx itself must be + * held. A condition variable, mac_policy_cv, is used to signal potential + * exclusive consumers that they should try to acquire the lock if a first + * attempt at exclusive access fails. + * + * This design intentionally avoids fairness, and may starve attempts to + * acquire an exclusive lock on a busy system. This is required because we + * do not ever want acquiring a read reference to perform an unbounded length + * sleep. Read references are acquired in ithreads, network isrs, etc, and + * any unbounded blocking could lead quickly to deadlock. + * + * Another reason for never blocking on read references is that the MAC + * Framework may recurse: if a policy calls a VOP, for example, this might + * lead to vnode life cycle operations (such as init/destroy). + * + * If the kernel option MAC_STATIC has been compiled in, all locking becomes + * a no-op, and the global list of policies is not allowed to change after + * early boot. + * + * XXXRW: Currently, we signal mac_policy_cv every time the framework becomes + * unbusy and there is a thread waiting to enter it exclusively. Since it + * may take some time before the thread runs, we may issue a lot of signals. + * We should instead keep track of the fact that we've signalled, taking into + * account that the framework may be busy again by the time the thread runs, + * requiring us to re-signal. + */ + /* + * XXX HSH: Without modules we will be always static. + * XXX HSH: For now I will always 'if 0' this kind of code. + */ +#if 0 +#ifndef MAC_STATIC +static struct mtx mac_policy_mtx; +static struct cv mac_policy_cv; +static int mac_policy_count; +static int mac_policy_wait; +#endif +#endif /* 0 */ +struct mac_policy_list_head mac_policy_list; +struct mac_policy_list_head mac_static_policy_list; + +/* + * We manually invoke WITNESS_WARN() to allow Witness to generate warnings + * even if we don't end up ever triggering the wait at run-time. The + * consumer of the exclusive interface must not hold any locks (other than + * potentially Giant) since we may sleep for long (potentially indefinite) + * periods of time waiting for the framework to become quiescent so that a + * policy list change may be made. + */ +void +mac_policy_grab_exclusive(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + if (!mac_late) + return; + + WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, + "mac_policy_grab_exclusive() at %s:%d", __FILE__, __LINE__); + mtx_lock(&mac_policy_mtx); + while (mac_policy_count != 0) { + mac_policy_wait++; + cv_wait(&mac_policy_cv, &mac_policy_mtx); + mac_policy_wait--; + } +#endif +#endif /* 0 */ +} + +void +mac_policy_assert_exclusive(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + if (!mac_late) + return; + + mtx_assert(&mac_policy_mtx, MA_OWNED); + KASSERT(mac_policy_count == 0); +#endif +#endif /* 0 */ +} + +void +mac_policy_release_exclusive(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + int dowakeup; + + if (!mac_late) + return; + + KASSERT(mac_policy_count == 0); + dowakeup = (mac_policy_wait != 0); + mtx_unlock(&mac_policy_mtx); + if (dowakeup) + cv_signal(&mac_policy_cv); +#endif +#endif /* 0 */ +} + +void +mac_policy_list_busy(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + if (!mac_late) + return; + + mtx_lock(&mac_policy_mtx); + mac_policy_count++; + mtx_unlock(&mac_policy_mtx); +#endif +#endif /* 0 */ +} + +int +mac_policy_list_conditional_busy(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + int ret; + + if (!mac_late) + return (1); + + mtx_lock(&mac_policy_mtx); + if (!LIST_EMPTY(&mac_policy_list)) { + mac_policy_count++; + ret = 1; + } else + ret = 0; + mtx_unlock(&mac_policy_mtx); + return (ret); +#else + return (1); +#endif +#else /* 0 XXX HSH */ + return (1); +#endif /* 0 XXX HSH */ +} + +void +mac_policy_list_unbusy(void) +{ +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + int dowakeup; + + if (!mac_late) + return; + + mtx_lock(&mac_policy_mtx); + mac_policy_count--; + KASSERT(mac_policy_count >= 0); + dowakeup = (mac_policy_count == 0 && mac_policy_wait != 0); + mtx_unlock(&mac_policy_mtx); + + if (dowakeup) + cv_signal(&mac_policy_cv); +#endif +#endif /* 0 */ +} + +/* + * Initialize the MAC subsystem, including appropriate SMP locks. + */ +void +mac_init(void) +{ + int i, error; + + LIST_INIT(&mac_static_policy_list); + LIST_INIT(&mac_policy_list); + mac_labelpool_init(); + +#if 0 /* XXX HSH */ +#ifndef MAC_STATIC + mtx_init(&mac_policy_mtx, "mac_policy_mtx", NULL, MTX_DEF); + cv_init(&mac_policy_cv, "mac_policy_cv"); +#endif +#endif /* 0 */ + + for (i = 0; i < MAC_MAX_SLOTS && mac_policies[i] != 0; i++) { + if ((error = mac_policy_register(mac_policies[i])) != 0) + printf("failed to register %s, error %d\n", + mac_policies[i]->mpc_fullname, error); + } + + mac_late_init(); +} + +/* + * For the purposes of modules that want to know if they were loaded "early", + * set the mac_late flag once we've processed modules either linked into the + * kernel, or loaded before the kernel startup. + */ +static void +mac_late_init(void) +{ + + mac_late = 1; +} + +/* + * After the policy list has changed, walk the list to update any global + * flags. Currently, we support only one flag, and it's conditionally + * defined; as a result, the entire function is conditional. Eventually, the + * #else case might also iterate across the policies. + */ +static void +mac_policy_updateflags(void) +{ +#ifndef MAC_ALWAYS_LABEL_MBUF + struct mac_policy_conf *tmpc; + int labelmbufs; + + mac_policy_assert_exclusive(); + + labelmbufs = 0; + LIST_FOREACH(tmpc, &mac_static_policy_list, mpc_list) { + if (tmpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_LABELMBUFS) + labelmbufs++; + } + LIST_FOREACH(tmpc, &mac_policy_list, mpc_list) { + if (tmpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_LABELMBUFS) + labelmbufs++; + } + mac_labelmbufs = (labelmbufs != 0); +#endif +} + +static int +mac_policy_register(struct mac_policy_conf *mpc) +{ + struct mac_policy_conf *tmpc; + int error, slot, static_entry; + + error = 0; + + /* + * We don't technically need exclusive access while !mac_late, but + * hold it for assertion consistency. + */ + mac_policy_grab_exclusive(); + + /* + * If the module can potentially be unloaded, or we're loading late, + * we have to stick it in the non-static list and pay an extra + * performance overhead. Otherwise, we can pay a light locking cost + * and stick it in the static list. + * + * XXX HSH: We might have static entries only, so we could get rid + * XXX HSH: of mac_late and loadtime flags. + */ + static_entry = (!mac_late && + !(mpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_UNLOADOK)); + +#ifdef MAC_DEBUG + printf("mac_policy_register: mpc %p (%s) static_entry %d\n", mpc, + mpc->mpc_name, static_entry); +#endif + + if (static_entry) { + LIST_FOREACH(tmpc, &mac_static_policy_list, mpc_list) { + if (strcmp(tmpc->mpc_name, mpc->mpc_name) == 0) { + error = EEXIST; + goto out; + } + } + } else { + LIST_FOREACH(tmpc, &mac_policy_list, mpc_list) { + if (strcmp(tmpc->mpc_name, mpc->mpc_name) == 0) { + error = EEXIST; + goto out; + } + } + } +#ifdef MAC_DEBUG + printf("mac_policy_register: mac_slots_offsets_free %#x " + "mpc_field_off %#x mpc_runtime_flags %#x\n", + mac_slot_offsets_free, *mpc->mpc_field_off, + mpc->mpc_runtime_flags); +#endif + if (mpc->mpc_field_off != NULL) { + slot = ffs(mac_slot_offsets_free); + if (slot == 0) { + error = ENOMEM; + goto out; + } + slot--; + mac_slot_offsets_free &= ~(1 << slot); + *mpc->mpc_field_off = slot; + } + mpc->mpc_runtime_flags |= MPC_RUNTIME_FLAG_REGISTERED; +#ifdef MAC_DEBUG + printf("mac_policy_register: mac_slots_offsets_free %#x " + "mpc_field_off %#x mpc_runtime_flags %#x\n", + mac_slot_offsets_free, *mpc->mpc_field_off, + mpc->mpc_runtime_flags); +#endif + + /* + * If we're loading a MAC module after the framework has initialized, + * it has to go into the dynamic list. If we're loading it before + * we've finished initializing, it can go into the static list with + * weaker locker requirements. + */ + if (static_entry) + LIST_INSERT_HEAD(&mac_static_policy_list, mpc, mpc_list); + else + LIST_INSERT_HEAD(&mac_policy_list, mpc, mpc_list); + + /* + * Per-policy initialization. Currently, this takes place under the + * exclusive lock, so policies must not sleep in their init method. + * In the future, we may want to separate "init" from "start", with + * "init" occuring without the lock held. Likewise, on tear-down, + * breaking out "stop" from "destroy". + */ + if (mpc->mpc_ops->mpo_init != NULL) + (*(mpc->mpc_ops->mpo_init))(mpc); + mac_policy_updateflags(); + + printf("Security policy loaded: %s (%s)\n", mpc->mpc_fullname, + mpc->mpc_name); + +#ifdef MAC_DEBUG + printf("mac_policy_register: mac_static_policy_list\n"); + LIST_FOREACH(tmpc, &mac_static_policy_list, mpc_list) + printf("\t%s\n", tmpc->mpc_name); + printf("mac_policy_register: mac_policy_list\n"); + LIST_FOREACH(tmpc, &mac_policy_list, mpc_list) + printf("\t%s\n", tmpc->mpc_name); +#endif + +out: + mac_policy_release_exclusive(); + return (error); +} + +#if 0 /* XXX HSH */ +static int +mac_policy_unregister(struct mac_policy_conf *mpc) +{ + + /* + * If we fail the load, we may get a request to unload. Check to see + * if we did the run-time registration, and if not, silently succeed. + */ + mac_policy_grab_exclusive(); + if ((mpc->mpc_runtime_flags & MPC_RUNTIME_FLAG_REGISTERED) == 0) { + mac_policy_release_exclusive(); + return (0); + } +#if 0 /* XXX HSH */ + /* + * Don't allow unloading modules with private data. + */ + if (mpc->mpc_field_off != NULL) { + MAC_POLICY_LIST_UNLOCK(); + return (EBUSY); + } +#endif + /* + * Only allow the unload to proceed if the module is unloadable by + * its own definition. + */ + if ((mpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_UNLOADOK) == 0) { + mac_policy_release_exclusive(); + return (EBUSY); + } + if (mpc->mpc_ops->mpo_destroy != NULL) + (*(mpc->mpc_ops->mpo_destroy))(mpc); + + LIST_REMOVE(mpc, mpc_list); + mpc->mpc_runtime_flags &= ~MPC_RUNTIME_FLAG_REGISTERED; + mac_policy_updateflags(); + + mac_policy_release_exclusive(); + + printf("Security policy unload: %s (%s)\n", mpc->mpc_fullname, + mpc->mpc_name); + + return (0); +} + +/* + * Allow MAC policy modules to register during boot, etc. + */ +int +mac_policy_modevent(module_t mod, int type, void *data) +{ + struct mac_policy_conf *mpc; + int error; + + error = 0; + mpc = (struct mac_policy_conf *) data; + +#ifdef MAC_STATIC + if (mac_late) { + printf("mac_policy_modevent: MAC_STATIC and late\n"); + return (EBUSY); + } +#endif + + switch (type) { + case MOD_LOAD: + if (mpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_NOTLATE && + mac_late) { + printf("mac_policy_modevent: can't load %s policy " + "after booting\n", mpc->mpc_name); + error = EBUSY; + break; + } + error = mac_policy_register(mpc); + break; + case MOD_UNLOAD: + /* Don't unregister the module if it was never registered. */ + if ((mpc->mpc_runtime_flags & MPC_RUNTIME_FLAG_REGISTERED) + != 0) + error = mac_policy_unregister(mpc); + else + error = 0; + break; + default: + error = EOPNOTSUPP; + break; + } + + return (error); +} +#endif /* 0 */ + +/* + * Define an error value precedence, and given two arguments, selects the + * value with the higher precedence. + */ +int +mac_error_select(int error1, int error2) +{ + + /* Certain decision-making errors take top priority. */ + if (error1 == EDEADLK || error2 == EDEADLK) + return (EDEADLK); + + /* Invalid arguments should be reported where possible. */ + if (error1 == EINVAL || error2 == EINVAL) + return (EINVAL); + + /* Precedence goes to "visibility", with both process and file. */ + if (error1 == ESRCH || error2 == ESRCH) + return (ESRCH); + + if (error1 == ENOENT || error2 == ENOENT) + return (ENOENT); + + /* Precedence goes to DAC/MAC protections. */ + if (error1 == EACCES || error2 == EACCES) + return (EACCES); + + /* Precedence goes to privilege. */ + if (error1 == EPERM || error2 == EPERM) + return (EPERM); + + /* Precedence goes to error over success; otherwise, arbitrary. */ + if (error1 != 0) + return (error1); + return (error2); +} + +int +mac_check_structmac_consistent(struct mac *mac) +{ + + if (mac->m_buflen < 0 || + mac->m_buflen > MAC_MAX_LABEL_BUF_LEN) + return (EINVAL); + + return (0); +} + +/* + * Security sysctl. + */ +int +security_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, + void *newp, size_t newlen, struct proc *p) +{ + switch (name[0]) { + case SECURITY_VERSION: + return (sysctl_rdint(oldp, oldlenp, newp, mac_version)); + +#ifdef MAC_TEST + case SECURITY_MAC_TEST: + switch (name[1]) { + case MAC_POLICY_ENABLED: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_enabled)); + case MAC_TEST_BPFDESC_CHECK_RECEIVE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_bpfdesc_check_receive)); + case MAC_TEST_BPFDESC_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_bpfdesc_create)); + case MAC_TEST_BPFDESC_CREATE_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_bpfdesc_create_mbuf)); + case MAC_TEST_BPFDESC_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_bpfdesc_destroy_label)); + case MAC_TEST_BPFDESC_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_bpfdesc_init_label)); + case MAC_TEST_CRED_CHECK_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_check_relabel)); + case MAC_TEST_CRED_CHECK_VISIBLE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_check_visible)); + case MAC_TEST_CRED_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_copy_label)); + case MAC_TEST_CRED_CREATE_INIT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_create_init)); + case MAC_TEST_CRED_CREATE_SWAPPER: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_create_swapper)); + case MAC_TEST_CRED_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_destroy_label)); + case MAC_TEST_CRED_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_externalize_label)); + case MAC_TEST_CRED_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_init_label)); + case MAC_TEST_CRED_INTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_internalize_label)); + case MAC_TEST_CRED_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_cred_relabel)); + case MAC_TEST_IFNET_CHECK_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_check_relabel)); + case MAC_TEST_IFNET_CHECK_TRANSMIT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_check_transmit)); + case MAC_TEST_IFNET_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_copy_label)); + case MAC_TEST_IFNET_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_create)); + case MAC_TEST_IFNET_CREATE_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_create_mbuf)); + case MAC_TEST_IFNET_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_destroy_label)); + case MAC_TEST_IFNET_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_externalize_label)); + case MAC_TEST_IFNET_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_init_label)); + case MAC_TEST_IFNET_INTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_internalize_label)); + case MAC_TEST_IFNET_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ifnet_relabel)); + case MAC_TEST_INPCB_CHECK_DELIVER: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_check_deliver)); + case MAC_TEST_INPCB_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_create)); + case MAC_TEST_INPCB_CREATE_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_create_mbuf)); + case MAC_TEST_INPCB_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_destroy_label)); + case MAC_TEST_INPCB_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_init_label)); + case MAC_TEST_INPCB_SOSETLABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_inpcb_sosetlabel)); + case MAC_TEST_IPQ_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_create)); + case MAC_TEST_IPQ_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_destroy_label)); + case MAC_TEST_IPQ_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_init_label)); + case MAC_TEST_IPQ_MATCH: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_match)); + case MAC_TEST_IPQ_REASSEMBLE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_reassemble)); + case MAC_TEST_IPQ_UPDATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_ipq_update)); + case MAC_TEST_MBUF_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mbuf_copy_label)); + case MAC_TEST_MBUF_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mbuf_destroy_label)); + case MAC_TEST_MBUF_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mbuf_init_label)); + case MAC_TEST_MOUNT_CHECK_STAT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mount_check_stat)); + case MAC_TEST_MOUNT_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mount_create)); + case MAC_TEST_MOUNT_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mount_destroy_label)); + case MAC_TEST_MOUNT_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_mount_init_label)); + case MAC_TEST_NETINET_ARP_SEND: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_arp_send)); + case MAC_TEST_NETINET_FRAGMENT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_fragment)); + case MAC_TEST_NETINET_ICMP_REPLY: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_icmp_reply)); + case MAC_TEST_NETINET_ICMP_REPLYINPLACE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_icmp_replyinplace)); + case MAC_TEST_NETINET_IGMP_SEND: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_igmp_send)); + case MAC_TEST_NETINET_TCP_REPLY: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_netinet_tcp_reply)); + case MAC_TEST_PIPE_CHECK_IOCTL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_ioctl)); + case MAC_TEST_PIPE_CHECK_POLL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_poll)); + case MAC_TEST_PIPE_CHECK_READ: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_read)); + case MAC_TEST_PIPE_CHECK_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_relabel)); + case MAC_TEST_PIPE_CHECK_STAT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_stat)); + case MAC_TEST_PIPE_CHECK_WRITE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_check_write)); + case MAC_TEST_PIPE_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_copy_label)); + case MAC_TEST_PIPE_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_create)); + case MAC_TEST_PIPE_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_destroy_label)); + case MAC_TEST_PIPE_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_externalize_label)); + case MAC_TEST_PIPE_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_init_label)); + case MAC_TEST_PIPE_INTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_internalize_label)); + case MAC_TEST_PIPE_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_pipe_relabel)); + case MAC_TEST_PROC_CHECK_DEBUG: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_debug)); + case MAC_TEST_PROC_CHECK_SCHED: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_sched)); + case MAC_TEST_PROC_CHECK_SIGNAL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_signal)); + case MAC_TEST_PROC_CHECK_SETEGID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setegid)); + case MAC_TEST_PROC_CHECK_EUID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_euid)); + case MAC_TEST_PROC_CHECK_SETREGID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setregid)); + case MAC_TEST_PROC_CHECK_SETREUID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setreuid)); + case MAC_TEST_PROC_CHECK_SETGID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setgid)); + case MAC_TEST_PROC_CHECK_SETGROUPS: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setgroups)); + case MAC_TEST_PROC_CHECK_SETRESGID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setresgid)); + case MAC_TEST_PROC_CHECK_SETRESUID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setresuid)); + case MAC_TEST_PROC_CHECK_SETUID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_setuid)); + case MAC_TEST_PROC_CHECK_WAIT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_check_wait)); + case MAC_TEST_PROC_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_destroy_label)); + case MAC_TEST_PROC_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_init_label)); + case MAC_TEST_PROC_USERRET: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_proc_userret)); + case MAC_TEST_SOCKET_CHECK_ACCEPT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_accept)); + case MAC_TEST_SOCKET_CHECK_BIND: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_bind)); + case MAC_TEST_SOCKET_CHECK_CONNECT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_connect)); + case MAC_TEST_SOCKET_CHECK_LISTEN: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_listen)); + case MAC_TEST_SOCKET_CHECK_POLL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_poll)); + case MAC_TEST_SOCKET_CHECK_RECEIVE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_receive)); + case MAC_TEST_SOCKET_CHECK_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_relabel)); + case MAC_TEST_SOCKET_CHECK_SEND: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_send)); + case MAC_TEST_SOCKET_CHECK_STAT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_stat)); + case MAC_TEST_SOCKET_CHECK_VISIBLE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_check_visible)); + case MAC_TEST_SOCKET_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_copy_label)); + case MAC_TEST_SOCKET_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_create)); + case MAC_TEST_SOCKET_CREATE_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_create_mbuf)); + case MAC_TEST_SOCKET_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_destroy_label)); + case MAC_TEST_SOCKET_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_externalize_label)); + case MAC_TEST_SOCKET_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_init_label)); + case MAC_TEST_SOCKET_INTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_internalize_label)); + case MAC_TEST_SOCKET_NEWCONN: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_newconn)); + case MAC_TEST_SOCKET_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socket_relabel)); + case MAC_TEST_SOCKETPEER_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socketpeer_destroy_label)); + case MAC_TEST_SOCKETPEER_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socketpeer_externalize_label)); + case MAC_TEST_SOCKETPEER_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socketpeer_init_label)); + case MAC_TEST_SOCKETPEER_SET_FROM_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socketpeer_set_from_mbuf)); + case MAC_TEST_SOCKETPEER_SET_FROM_SOCKET: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_socketpeer_set_from_socket)); + case MAC_TEST_SYNCACHE_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_syncache_create)); + case MAC_TEST_SYNCACHE_CREATE_MBUF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_syncache_create_mbuf)); + case MAC_TEST_SYNCACHE_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_syncache_destroy_label)); + case MAC_TEST_SYNCACHE_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_syncache_init_label)); + case MAC_TEST_SYSTEM_CHECK_ACCT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_system_check_acct)); + case MAC_TEST_SYSTEM_CHECK_REBOOT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_system_check_reboot)); + case MAC_TEST_SYSTEM_CHECK_SWAPOFF: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_system_check_swapoff)); + case MAC_TEST_SYSTEM_CHECK_SWAPON: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_system_check_swapon)); + case MAC_TEST_SYSTEM_CHECK_SYSCTL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_system_check_sysctl)); + case MAC_TEST_SYSVMSG_CLEANUP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsg_cleanup)); + case MAC_TEST_SYSVMSG_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsg_create)); + case MAC_TEST_SYSVMSG_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsg_init_label)); + case MAC_TEST_SYSVMSQ_CHECK_MSGMSQ: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msgmsq)); + case MAC_TEST_SYSVMSQ_CHECK_MSGRCV: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msgrcv)); + case MAC_TEST_SYSVMSQ_CHECK_MSGRMID: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msgrmid)); + case MAC_TEST_SYSVMSQ_CHECK_MSQGET: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msqget)); + case MAC_TEST_SYSVMSQ_CHECK_MSQSND: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msqsnd)); + case MAC_TEST_SYSVMSQ_CHECK_MSQRCV: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msqrcv)); + case MAC_TEST_SYSVMSQ_CHECK_MSQCTL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_check_msqctl)); + case MAC_TEST_SYSVMSQ_CLEANUP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_cleanup)); + case MAC_TEST_SYSVMSQ_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_create)); + case MAC_TEST_SYSVMSQ_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvmsq_init_label)); + case MAC_TEST_SYSVSEM_CHECK_SEMCTL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_check_semctl)); + case MAC_TEST_SYSVSEM_CHECK_SEMGET: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_check_semget)); + case MAC_TEST_SYSVSEM_CHECK_SEMOP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_check_semop)); + case MAC_TEST_SYSVSEM_CLEANUP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_cleanup)); + case MAC_TEST_SYSVSEM_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_create)); + case MAC_TEST_SYSVSEM_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_destroy_label)); + case MAC_TEST_SYSVSEM_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvsem_init_label)); + case MAC_TEST_SYSVSHM_CHECK_SHMAT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_check_shmat)); + case MAC_TEST_SYSVSHM_CHECK_SHMCTL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_check_shmctl)); + case MAC_TEST_SYSVSHM_CHECK_SHMDT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_check_shmdt)); + case MAC_TEST_SYSVSHM_CHECK_SHMGET: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_check_shmget)); + case MAC_TEST_SYSVSHM_CLEANUP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_cleanup)); + case MAC_TEST_SYSVSHM_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_create)); + case MAC_TEST_SYSVSHM_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_destroy_label)); + case MAC_TEST_SYSVSHM_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_sysvshm_init_label)); + case MAC_TEST_VNODE_ASSOCIATE_EXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_associate_extattr)); + case MAC_TEST_VNODE_ASSOCIATE_SINGLELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_associate_singlelabel)); + case MAC_TEST_VNODE_CHECK_ACCESS: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_access)); + case MAC_TEST_VNODE_CHECK_CHDIR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_chdir)); + case MAC_TEST_VNODE_CHECK_CHROOT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_chroot)); + case MAC_TEST_VNODE_CHECK_CREATE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_create)); + case MAC_TEST_VNODE_CHECK_DELETEACL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_deleteacl)); + case MAC_TEST_VNODE_CHECK_DELETEEXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_deleteextattr)); + case MAC_TEST_VNODE_CHECK_EXEC: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_exec)); + case MAC_TEST_VNODE_CHECK_GETACL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_getacl)); + case MAC_TEST_VNODE_CHECK_GETEXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_getextattr)); + case MAC_TEST_VNODE_CHECK_LINK: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_link)); + case MAC_TEST_VNODE_CHECK_LISTEXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_listextattr)); + case MAC_TEST_VNODE_CHECK_LOOKUP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_lookup)); + case MAC_TEST_VNODE_CHECK_MMAP: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_mmap)); + case MAC_TEST_VNODE_CHECK_OPEN: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_open)); + case MAC_TEST_VNODE_CHECK_POLL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_poll)); + case MAC_TEST_VNODE_CHECK_READ: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_read)); + case MAC_TEST_VNODE_CHECK_READDIR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_readdir)); + case MAC_TEST_VNODE_CHECK_READLINK: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_readlink)); + case MAC_TEST_VNODE_CHECK_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_relabel)); + case MAC_TEST_VNODE_CHECK_RENAME_FROM: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_rename_from)); + case MAC_TEST_VNODE_CHECK_RENAME_TO: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_rename_to)); + case MAC_TEST_VNODE_CHECK_REVOKE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_revoke)); + case MAC_TEST_VNODE_CHECK_SETACL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setacl)); + case MAC_TEST_VNODE_CHECK_SETEXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setextattr)); + case MAC_TEST_VNODE_CHECK_SETFLAGS: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setflags)); + case MAC_TEST_VNODE_CHECK_SETMODE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setmode)); + case MAC_TEST_VNODE_CHECK_SETOWNER: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setowner)); + case MAC_TEST_VNODE_CHECK_SETUTIMES: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_setutimes)); + case MAC_TEST_VNODE_CHECK_STAT: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_stat)); + case MAC_TEST_VNODE_CHECK_UNLINK: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_unlink)); + case MAC_TEST_VNODE_CHECK_WRITE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_check_write)); + case MAC_TEST_VNODE_COPY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_copy_label)); + case MAC_TEST_VNODE_CREATE_EXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_create_extattr)); + case MAC_TEST_VNODE_DESTROY_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_destroy_label)); + case MAC_TEST_VNODE_EXECVE_TRANSITION: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_execve_transition)); + case MAC_TEST_VNODE_EXECVE_WILL_TRANSITION: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_execve_will_transition)); + case MAC_TEST_VNODE_EXTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_externalize_label)); + case MAC_TEST_VNODE_INIT_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_init_label)); + case MAC_TEST_VNODE_INTERNALIZE_LABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_internalize_label)); + case MAC_TEST_VNODE_RELABEL: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_relabel)); + case MAC_TEST_VNODE_SETLABEL_EXTATTR: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_test_vnode_setlabel_extattr)); + default: + return (EOPNOTSUPP); + } +#endif /* MAC_TEST */ + +#ifdef ANOUBIS + case SECURITY_ANOUBIS: + switch(name[1]) { + case MAC_POLICY_ENABLED: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &mac_anoubis_enabled)); + case ANOUBIS_ALF_ENABLE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &alf_enable)); + case ANOUBIS_ALF_ALLOW_PORT_MIN: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &alf_allow_port_min)); + case ANOUBIS_ALF_ALLOW_PORT_MAX: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &alf_allow_port_max)); + case ANOUBIS_SFS_ENABLE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &sfs_enable)); + default: + return (EOPNOTSUPP); + } +#endif /* ANOUBIS */ + + default: + return (EOPNOTSUPP); + } + /* NOTREACHED */ +} diff --git a/sys/security/mac/mac_framework.h b/sys/security/mac/mac_framework.h new file mode 100644 index 0000000..17c140a --- /dev/null +++ b/sys/security/mac/mac_framework.h @@ -0,0 +1,503 @@ +/* + * Copyright (c) 1999-2002, 2007-2008 Robert N. M. Watson + * Copyright (c) 2001-2005 Networks Associates Technology, Inc. + * Copyright (c) 2005-2006 SPARTA, Inc. + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_framework.h,v 1.106 2008/10/28 13:44:11 trasz Exp $ + */ + +/* + * Kernel interface for Mandatory Access Control -- how kernel services + * interact with the TrustedBSD MAC Framework. + */ + +#ifndef _SECURITY_MAC_MAC_FRAMEWORK_H_ +#define _SECURITY_MAC_MAC_FRAMEWORK_H_ + +#ifndef _KERNEL +#error "no user-serviceable parts inside" +#endif + +struct bpf_d; +struct cdev; +struct componentname; +struct exec_package; +struct ifnet; +struct ifreq; +struct inpcb; +struct ipq; +struct label; +struct m_tag; +struct mac; +struct mbuf; +struct mount; +struct msg; +struct msqid_kernel; +struct nameidata; +struct proc; +struct semid_kernel; +struct shmid_kernel; +struct sockaddr; +struct socket; +struct pipepair; +struct timespec; +struct ucred; +struct uio; +struct vattr; +struct vnode; +struct sys___sysctl_args; + +#include /* XXX acl_type_t */ +#include /* accmode_t */ + +/* + * Entry points to the TrustedBSD MAC Framework from the remainder of the + * kernel: entry points are named based on a principle object type and an + * action relating to it. They are sorted alphabetically first by object + * type and then action. In some situations, the principle object type is + * obvious, and in other cases, less so as multiple objects may be inolved + * in the operation. + */ +int mac_bpfdesc_check_receive(struct bpf_d *d, struct ifnet *ifp); +void mac_bpfdesc_create(struct ucred *cred, struct bpf_d *d); +void mac_bpfdesc_create_mbuf(struct bpf_d *d, struct mbuf *m); +void mac_bpfdesc_destroy(struct bpf_d *); +void mac_bpfdesc_init(struct bpf_d *); + +#ifdef ANOUBIS +int mac_check_follow_link(struct nameidata *, char *linkbuf, int linklen); +#endif + +void mac_cred_associate_nfsd(struct ucred *cred); +int mac_cred_check_visible(struct ucred *cr1, struct ucred *cr2); +void mac_cred_copy(struct ucred *cr1, struct ucred *cr2); +void mac_cred_create_init(struct ucred *cred); +void mac_cred_create_swapper(struct ucred *cred); +void mac_cred_destroy(struct ucred *); +void mac_cred_init(struct ucred *); + +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +void mac_devfs_create_device(struct ucred *cred, struct mount *mp, + struct cdev *dev, struct devfs_dirent *de); +void mac_devfs_create_directory(struct mount *mp, char *dirname, + int dirnamelen, struct devfs_dirent *de); +void mac_devfs_create_symlink(struct ucred *cred, struct mount *mp, + struct devfs_dirent *dd, struct devfs_dirent *de); +void mac_devfs_destroy(struct devfs_dirent *); +void mac_devfs_init(struct devfs_dirent *); +void mac_devfs_update(struct mount *mp, struct devfs_dirent *de, + struct vnode *vp); +void mac_devfs_vnode_associate(struct mount *mp, struct devfs_dirent *de, + struct vnode *vp); +#endif + +int mac_execve_enter(struct exec_package *pack, struct mac *mac_p); +void mac_execve_exit(struct exec_package *pack); +void mac_execve_interpreter_enter(struct vnode *interpvp, + struct label **interplabel); +void mac_execve_interpreter_exit(struct label *interpvplabel); +#ifdef ANOUBIS +int mac_execve_prepare(struct exec_package *pack); +void mac_execve_success(struct exec_package *pack); +#endif + +int mac_ifnet_check_transmit(struct ifnet *ifp, struct mbuf *m); +void mac_ifnet_create(struct ifnet *ifp); +void mac_ifnet_create_mbuf(struct ifnet *ifp, struct mbuf *m); +void mac_ifnet_destroy(struct ifnet *); +void mac_ifnet_init(struct ifnet *); +int mac_ifnet_ioctl_get(struct ucred *cred, struct ifreq *ifr, + struct ifnet *ifp); +int mac_ifnet_ioctl_set(struct ucred *cred, struct ifreq *ifr, + struct ifnet *ifp); + +int mac_inpcb_check_deliver(struct inpcb *inp, struct mbuf *m); +int mac_inpcb_check_visible(struct ucred *cred, struct inpcb *inp); +void mac_inpcb_create(struct socket *so, struct inpcb *inp); +void mac_inpcb_create_mbuf(struct inpcb *inp, struct mbuf *m); +void mac_inpcb_destroy(struct inpcb *); +int mac_inpcb_init(struct inpcb *, int); +void mac_inpcb_sosetlabel(struct socket *so, struct inpcb *inp); + +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +void mac_ip6q_create(struct mbuf *m, struct ip6q *q6); +void mac_ip6q_destroy(struct ip6q *q6); +int mac_ip6q_init(struct ip6q *q6, int); +int mac_ip6q_match(struct mbuf *m, struct ip6q *q6); +void mac_ip6q_reassemble(struct ip6q *q6, struct mbuf *m); +void mac_ip6q_update(struct mbuf *m, struct ip6q *q6); +#endif + +void mac_ipq_create(struct mbuf *m, struct ipq *q); +void mac_ipq_destroy(struct ipq *q); +int mac_ipq_init(struct ipq *q, int); +int mac_ipq_match(struct mbuf *m, struct ipq *q); +void mac_ipq_reassemble(struct ipq *q, struct mbuf *m); +void mac_ipq_update(struct mbuf *m, struct ipq *q); + +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +int mac_kenv_check_dump(struct ucred *cred); +int mac_kenv_check_get(struct ucred *cred, char *name); +int mac_kenv_check_set(struct ucred *cred, char *name, char *value); +int mac_kenv_check_unset(struct ucred *cred, char *name); + +int mac_kld_check_load(struct ucred *cred, struct vnode *vp); +int mac_kld_check_stat(struct ucred *cred); +#endif + +void mac_mbuf_copy(struct mbuf *, struct mbuf *); +int mac_mbuf_init(struct mbuf *, int); + +void mac_mbuf_tag_copy(struct m_tag *, struct m_tag *); +void mac_mbuf_tag_destroy(struct m_tag *); +int mac_mbuf_tag_init(struct m_tag *, int); + +int mac_mount_check_stat(struct ucred *cred, struct mount *mp); +void mac_mount_create(struct ucred *cred, struct mount *mp); +void mac_mount_destroy(struct mount *); +void mac_mount_init(struct mount *); + +#if 0 /* XXX PM: AppleTalk is deprecated, we don't implement it in OpenBSD. */ +void mac_netatalk_aarp_send(struct ifnet *ifp, struct mbuf *m); +#endif + +void mac_netinet_arp_send(struct ifnet *ifp, struct mbuf *m); +void mac_netinet_firewall_reply(struct mbuf *mrecv, struct mbuf *msend); +void mac_netinet_firewall_send(struct mbuf *m); +void mac_netinet_fragment(struct mbuf *m, struct mbuf *frag); +void mac_netinet_icmp_reply(struct mbuf *mrecv, struct mbuf *msend); +void mac_netinet_icmp_replyinplace(struct mbuf *m); +void mac_netinet_igmp_send(struct ifnet *ifp, struct mbuf *m); +void mac_netinet_tcp_reply(struct mbuf *m); + +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +void mac_netinet6_nd6_send(struct ifnet *ifp, struct mbuf *m); +#endif + +int mac_pipe_check_ioctl(struct ucred *cred, struct pipepair *pp, + unsigned long cmd, void *data); +int mac_pipe_check_poll(struct ucred *cred, struct pipepair *pp); +int mac_pipe_check_read(struct ucred *cred, struct pipepair *pp); +int mac_pipe_check_stat(struct ucred *cred, struct pipepair *pp); +int mac_pipe_check_write(struct ucred *cred, struct pipepair *pp); +void mac_pipe_create(struct ucred *cred, struct pipepair *pp); +void mac_pipe_destroy(struct pipepair *); +void mac_pipe_init(struct pipepair *); +int mac_pipe_label_set(struct ucred *cred, struct pipepair *pp, + struct label *label); + +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +int mac_posixsem_check_getvalue(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks); +int mac_posixsem_check_open(struct ucred *cred, struct ksem *ks); +int mac_posixsem_check_post(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks); +int mac_posixsem_check_stat(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks); +int mac_posixsem_check_unlink(struct ucred *cred, struct ksem *ks); +int mac_posixsem_check_wait(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks); +void mac_posixsem_create(struct ucred *cred, struct ksem *ks); +void mac_posixsem_destroy(struct ksem *); +void mac_posixsem_init(struct ksem *); + +int mac_posixshm_check_mmap(struct ucred *cred, struct shmfd *shmfd, + int prot, int flags); +int mac_posixshm_check_open(struct ucred *cred, struct shmfd *shmfd); +int mac_posixshm_check_stat(struct ucred *active_cred, + struct ucred *file_cred, struct shmfd *shmfd); +int mac_posixshm_check_truncate(struct ucred *active_cred, + struct ucred *file_cred, struct shmfd *shmfd); +int mac_posixshm_check_unlink(struct ucred *cred, struct shmfd *shmfd); +void mac_posixshm_create(struct ucred *cred, struct shmfd *shmfd); +void mac_posixshm_destroy(struct shmfd *); +void mac_posixshm_init(struct shmfd *); +#endif + +int mac_priv_check(struct ucred *cred, int priv); +int mac_priv_grant(struct ucred *cred, int priv); + +int mac_proc_check_debug(struct ucred *cred, struct proc *p); +int mac_proc_check_sched(struct ucred *cred, struct proc *p); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +int mac_proc_check_setaudit(struct ucred *cred, struct auditinfo *ai); +int mac_proc_check_setaudit_addr(struct ucred *cred, + struct auditinfo_addr *aia); +int mac_proc_check_setauid(struct ucred *cred, uid_t auid); +#endif +int mac_proc_check_setegid(struct proc *p, struct ucred *cred, + gid_t egid); +int mac_proc_check_seteuid(struct proc *p, struct ucred *cred, + uid_t euid); +int mac_proc_check_setgid(struct proc *p, struct ucred *cred, + gid_t gid); +int mac_proc_check_setgroups(struct proc *p, struct ucred *cred, + int ngroups, gid_t *gidset); +int mac_proc_check_setregid(struct proc *p, struct ucred *cred, + gid_t rgid, gid_t egid); +int mac_proc_check_setresgid(struct proc *p, struct ucred *cred, + gid_t rgid, gid_t egid, gid_t sgid); +int mac_proc_check_setresuid(struct proc *p, struct ucred *cred, + uid_t ruid, uid_t euid, uid_t suid); +int mac_proc_check_setreuid(struct proc *p, struct ucred *cred, + uid_t ruid, uid_t euid); +int mac_proc_check_setuid(struct proc *p, struct ucred *cred, + uid_t uid); +int mac_proc_check_signal(struct ucred *cred, struct proc *p, + int signum); +int mac_proc_check_wait(struct ucred *cred, struct proc *p); +void mac_proc_destroy(struct proc *); +void mac_proc_init(struct proc *); +void mac_proc_vm_revoke(struct proc *p); + +int mac_socket_check_accept(struct ucred *cred, struct socket *so); +int mac_socket_check_accepted(struct ucred *cred, struct socket *so, + struct mbuf *name); +int mac_socket_check_bind(struct ucred *cred, struct socket *so, + const struct sockaddr *sa); +int mac_socket_check_connect(struct ucred *cred, struct socket *so, + const struct sockaddr *sa); +int mac_socket_check_create(struct ucred *cred, int domain, int type, + int proto); +#if 0 /* XXX PM: This hook is only called from the netatalk code. */ +int mac_socket_check_deliver(struct socket *so, struct mbuf *m); +#endif +int mac_socket_check_listen(struct ucred *cred, struct socket *so); +int mac_socket_check_poll(struct ucred *cred, struct socket *so); +int mac_socket_check_receive(struct ucred *cred, struct socket *so); +int mac_socket_check_soreceive(struct socket *so, struct mbuf *m); +int mac_socket_check_send(struct ucred *cred, struct socket *so); +int mac_socket_check_stat(struct ucred *cred, struct socket *so); +int mac_socket_check_visible(struct ucred *cred, struct socket *so); +void mac_socket_create_mbuf(struct socket *so, struct mbuf *m); +void mac_socket_create(struct ucred *cred, struct socket *so); +void mac_socket_destroy(struct socket *); +int mac_socket_init(struct socket *, int); +void mac_socket_newconn(struct socket *oldso, struct socket *newso); +int mac_getsockopt_label(struct ucred *cred, struct socket *so, + struct mac *extmac); +int mac_getsockopt_peerlabel(struct ucred *cred, struct socket *so, + struct mac *extmac); +int mac_setsockopt_label(struct ucred *cred, struct socket *so, + struct mac *extmac); + +void mac_socketpeer_set_from_mbuf(struct mbuf *m, struct socket *so); +void mac_socketpeer_set_from_socket(struct socket *oldso, + struct socket *newso); + +void mac_syncache_create(struct label *l, struct inpcb *inp); +void mac_syncache_create_mbuf(struct label *l, struct mbuf *m); +void mac_syncache_destroy(struct label **l); +int mac_syncache_init(struct label **l); + +int mac_system_check_acct(struct ucred *cred, struct vnode *vp); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +int mac_system_check_audit(struct ucred *cred, void *record, int length); +int mac_system_check_auditctl(struct ucred *cred, struct vnode *vp); +int mac_system_check_auditon(struct ucred *cred, int cmd); +#endif +int mac_system_check_reboot(struct ucred *cred, int howto); +int mac_system_check_swapon(struct ucred *cred, struct vnode *vp); +int mac_system_check_swapoff(struct ucred *cred, struct vnode *vp); +#if 0 /* XXX PM: Defined differently in OpenBSD. */ +int mac_system_check_sysctl(struct ucred *cred, struct sysctl_oid *oidp, + void *arg1, int arg2, struct sysctl_req *req); +#else +int mac_system_check_sysctl(struct ucred *cred, int *name, + struct sys___sysctl_args *uap, size_t oldlen); +#endif + +void mac_sysvmsg_cleanup(struct msg *msgptr); +void mac_sysvmsg_create(struct ucred *cred, struct msqid_kernel *msqkptr, + struct msg *msgptr); +#if 0 /* XXX PM: We never release SysV messages in OpenBSD. */ +void mac_sysvmsg_destroy(struct msg *); +#endif +void mac_sysvmsg_init(struct msg *); + +int mac_sysvmsq_check_msgmsq(struct ucred *cred, struct msg *msgptr, + struct msqid_kernel *msqkptr); +int mac_sysvmsq_check_msgrcv(struct ucred *cred, struct msg *msgptr); +int mac_sysvmsq_check_msgrmid(struct ucred *cred, struct msg *msgptr); +int mac_sysvmsq_check_msqctl(struct ucred *cred, + struct msqid_kernel *msqkptr, int cmd); +int mac_sysvmsq_check_msqget(struct ucred *cred, + struct msqid_kernel *msqkptr); +int mac_sysvmsq_check_msqrcv(struct ucred *cred, + struct msqid_kernel *msqkptr); +int mac_sysvmsq_check_msqsnd(struct ucred *cred, + struct msqid_kernel *msqkptr); +void mac_sysvmsq_cleanup(struct msqid_kernel *msqkptr); +void mac_sysvmsq_create(struct ucred *cred, struct msqid_kernel *msqkptr); +#if 0 /* XXX PM: We never release SysV messages in OpenBSD. */ +void mac_sysvmsq_destroy(struct msqid_kernel *); +#endif +void mac_sysvmsq_init(struct msqid_kernel *); + +int mac_sysvsem_check_semctl(struct ucred *cred, + struct semid_kernel *semakptr, int cmd); +int mac_sysvsem_check_semget(struct ucred *cred, + struct semid_kernel *semakptr); +int mac_sysvsem_check_semop(struct ucred *cred, + struct semid_kernel *semakptr, size_t accesstype); +void mac_sysvsem_cleanup(struct semid_kernel *semakptr); +void mac_sysvsem_create(struct ucred *cred, + struct semid_kernel *semakptr); +void mac_sysvsem_destroy(struct semid_kernel *); +void mac_sysvsem_init(struct semid_kernel *); + +int mac_sysvshm_check_shmat(struct ucred *cred, + struct shmid_kernel *shmsegptr, int shmflg); +int mac_sysvshm_check_shmctl(struct ucred *cred, + struct shmid_kernel *shmsegptr, int cmd); +int mac_sysvshm_check_shmdt(struct ucred *cred, + struct shmid_kernel *shmsegptr); +int mac_sysvshm_check_shmget(struct ucred *cred, + struct shmid_kernel *shmsegptr, int shmflg); +void mac_sysvshm_cleanup(struct shmid_kernel *shmsegptr); +void mac_sysvshm_create(struct ucred *cred, + struct shmid_kernel *shmsegptr); +void mac_sysvshm_destroy(struct shmid_kernel *); +void mac_sysvshm_init(struct shmid_kernel *); + +void mac_proc_userret(struct proc *p); + +int mac_vnode_associate_extattr(struct mount *mp, struct vnode *vp); +void mac_vnode_associate_singlelabel(struct mount *mp, struct vnode *vp); +int mac_vnode_check_access(struct ucred *cred, struct vnode *vp, + accmode_t accmode); +int mac_vnode_check_chdir(struct ucred *cred, struct vnode *dvp); +int mac_vnode_check_chroot(struct ucred *cred, struct vnode *dvp); +int mac_vnode_check_create(struct ucred *cred, struct vnode *dvp, + struct componentname *cnp, struct vattr *vap); +int mac_vnode_check_deleteacl(struct ucred *cred, struct vnode *vp, + acl_type_t type); +int mac_vnode_check_deleteextattr(struct ucred *cred, struct vnode *vp, + int attrnamespace, const char *name); +int mac_vnode_check_exec(struct ucred *cred, struct vnode *vp, + struct exec_package *pack); +int mac_vnode_check_getacl(struct ucred *cred, struct vnode *vp, + acl_type_t type); +int mac_vnode_check_getextattr(struct ucred *cred, struct vnode *vp, + int attrnamespace, const char *name, struct uio *uio); +#ifdef ANOUBIS +int mac_vnode_check_link(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, struct componentname *cnp, + struct vnode *sdvp, struct componentname *scnp); +#else +int mac_vnode_check_link(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, struct componentname *cnp); +#endif +int mac_vnode_check_listextattr(struct ucred *cred, struct vnode *vp, + int attrnamespace); +int mac_vnode_check_lookup(struct ucred *cred, struct vnode *dvp, + struct componentname *cnp); +int mac_vnode_check_mmap(struct ucred *cred, struct vnode *vp, int prot, + int flags); +#if 0 /* XXX PM: This hook does not seem to be called anywhere in FreeBSD. */ +int mac_vnode_check_mprotect(struct ucred *cred, struct vnode *vp, + int prot); +#endif +#ifdef ANOUBIS +int mac_vnode_check_truncate(struct ucred *cred, struct vnode *vp, + struct vnode *dirvp, struct componentname *cnp); +int mac_vnode_check_lock(struct ucred *cred, struct vnode *vp, + unsigned int op); +int mac_vnode_check_open(struct ucred *cred, struct vnode *vp, + int acc_mode, struct vnode *dirvp, struct componentname *cnp); +#else +int mac_vnode_check_open(struct ucred *cred, struct vnode *vp, + accmode_t accmode); +#endif +int mac_vnode_check_poll(struct ucred *active_cred, + struct ucred *file_cred, struct vnode *vp); +int mac_vnode_check_read(struct ucred *active_cred, + struct ucred *file_cred, struct vnode *vp); +int mac_vnode_check_readdir(struct ucred *cred, struct vnode *vp); +int mac_vnode_check_readlink(struct ucred *cred, struct vnode *vp); +int mac_vnode_check_rename_from(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, struct componentname *cnp); +int mac_vnode_check_rename_to(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, int samedir, struct componentname *cnp); +#ifdef ANOUBIS +int mac_vnode_check_rename_an(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, struct vnode *sdvp, + struct componentname *cnp, struct componentname *scnp); +#endif +int mac_vnode_check_revoke(struct ucred *cred, struct vnode *vp); +int mac_vnode_check_setacl(struct ucred *cred, struct vnode *vp, + acl_type_t type, struct acl *acl); +int mac_vnode_check_setextattr(struct ucred *cred, struct vnode *vp, + int attrnamespace, const char *name, struct uio *uio); +int mac_vnode_check_setflags(struct ucred *cred, struct vnode *vp, + u_long flags); +int mac_vnode_check_setmode(struct ucred *cred, struct vnode *vp, + mode_t mode); +int mac_vnode_check_setowner(struct ucred *cred, struct vnode *vp, + uid_t uid, gid_t gid); +int mac_vnode_check_setutimes(struct ucred *cred, struct vnode *vp, + struct timespec atime, struct timespec mtime); +int mac_vnode_check_stat(struct ucred *active_cred, + struct ucred *file_cred, struct vnode *vp); +int mac_vnode_check_unlink(struct ucred *cred, struct vnode *dvp, + struct vnode *vp, struct componentname *cnp); +int mac_vnode_check_write(struct ucred *active_cred, + struct ucred *file_cred, struct vnode *vp); +void mac_vnode_copy_label(struct label *, struct label *); +void mac_vnode_init(struct vnode *); +int mac_vnode_create_extattr(struct ucred *cred, struct mount *mp, + struct vnode *dvp, struct vnode *vp, struct componentname *cnp); +void mac_vnode_destroy(struct vnode *); +void mac_vnode_execve_transition(struct ucred *oldcred, + struct ucred *newcred, struct vnode *vp, + struct label *interpvplabel, struct exec_package *pack); +int mac_vnode_execve_will_transition(struct ucred *cred, + struct vnode *vp, struct label *interpvplabel, + struct exec_package *pack); +void mac_vnode_relabel(struct ucred *cred, struct vnode *vp, + struct label *newlabel); + +/* + * Calls to help various file systems implement labeling functionality using + * their existing EA implementation. + */ +#if 0 /* XXX PM: We prototype it in vnode.h. */ +int vop_stdsetlabel_ea(struct vop_setlabel_args *ap); +#endif + +/* XXX PM: Needed in OpenBSD. */ +void mac_init(void); + +#endif /* !_SECURITY_MAC_MAC_FRAMEWORK_H_ */ diff --git a/sys/security/mac/mac_inet.c b/sys/security/mac/mac_inet.c new file mode 100644 index 0000000..ea303cc --- /dev/null +++ b/sys/security/mac/mac_inet.c @@ -0,0 +1,452 @@ +/* + * Copyright (c) 1999-2002, 2007 Robert N. M. Watson + * Copyright (c) 2001 Ilmar S. Habibulin + * Copyright (c) 2001-2004 Networks Associates Technology, Inc. + * Copyright (c) 2006 SPARTA, Inc. + * Copyright (c) 2008 Apple Inc. + * All rights reserved. + * + * This software was developed by Robert Watson and Ilmar Habibulin for the + * TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_inet.c,v 1.22 2008/10/17 12:54:28 bz Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +/* XXX PM: No INP_LOCK_ASSERT() in OpenBSD. */ +#define INP_LOCK_ASSERT(inp) +/* XXX PM: No INP_WLOCK_ASSERT() in OpenBSD. */ +#define INP_WLOCK_ASSERT(inp) +/* XXX PM: No SOCK_LOCK_ASSERT() in OpenBSD. */ +#define SOCK_LOCK_ASSERT(x) + +/* XXX PM: These need to be prototyped here in OpenBSD. */ +struct label *mac_inpcb_label_alloc(int flag); +struct label *mac_ipq_label_alloc(int flag); +void mac_inpcb_label_free(struct label *label); +void mac_ipq_label_free(struct label *label); + +struct label * +mac_inpcb_label_alloc(int flag) +{ + struct label *label; + int error; + + label = mac_labelpool_alloc(flag); + if (label == NULL) + return (NULL); + MAC_CHECK(inpcb_init_label, label, flag); + if (error) { + MAC_PERFORM(inpcb_destroy_label, label); + mac_labelpool_free(label); + return (NULL); + } + return (label); +} + +int +mac_inpcb_init(struct inpcb *inp, int flag) +{ + + if (mac_labeled & MPC_OBJECT_INPCB) { + inp->inp_label = mac_inpcb_label_alloc(flag); + if (inp->inp_label == NULL) + return (ENOMEM); + } else + inp->inp_label = NULL; + return (0); +} + +struct label * +mac_ipq_label_alloc(int flag) +{ + struct label *label; + int error; + + label = mac_labelpool_alloc(flag); + if (label == NULL) + return (NULL); + + MAC_CHECK(ipq_init_label, label, flag); + if (error) { + MAC_PERFORM(ipq_destroy_label, label); + mac_labelpool_free(label); + return (NULL); + } + return (label); +} + +int +mac_ipq_init(struct ipq *q, int flag) +{ + + if (mac_labeled & MPC_OBJECT_IPQ) { + q->ipq_label = mac_ipq_label_alloc(flag); + if (q->ipq_label == NULL) + return (ENOMEM); + } else + q->ipq_label = NULL; + return (0); +} + +void +mac_inpcb_label_free(struct label *label) +{ + + MAC_PERFORM(inpcb_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_inpcb_destroy(struct inpcb *inp) +{ + + if (inp->inp_label != NULL) { + mac_inpcb_label_free(inp->inp_label); + inp->inp_label = NULL; + } +} + +void +mac_ipq_label_free(struct label *label) +{ + + MAC_PERFORM(ipq_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_ipq_destroy(struct ipq *q) +{ + + if (q->ipq_label != NULL) { + mac_ipq_label_free(q->ipq_label); + q->ipq_label = NULL; + } +} + +void +mac_inpcb_create(struct socket *so, struct inpcb *inp) +{ + + MAC_PERFORM(inpcb_create, so, so->so_label, inp, inp->inp_label); +} + +void +mac_ipq_reassemble(struct ipq *q, struct mbuf *m) +{ + struct label *label; + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(ipq_reassemble, q, q->ipq_label, m, label); +} + +void +mac_netinet_fragment(struct mbuf *m, struct mbuf *frag) +{ + struct label *mlabel, *fraglabel; + + mlabel = mac_mbuf_to_label(m); + fraglabel = mac_mbuf_to_label(frag); + + MAC_PERFORM(netinet_fragment, m, mlabel, frag, fraglabel); +} + +void +mac_ipq_create(struct mbuf *m, struct ipq *q) +{ + struct label *label; + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(ipq_create, m, label, q, q->ipq_label); +} + +void +mac_inpcb_create_mbuf(struct inpcb *inp, struct mbuf *m) +{ + struct label *mlabel; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + INP_LOCK_ASSERT(inp); + mlabel = mac_mbuf_to_label(m); + /* XXX PM: The following hook must not sleep. */ + MAC_PERFORM(inpcb_create_mbuf, inp, inp->inp_label, m, mlabel); + splx(s); +} + +int +mac_ipq_match(struct mbuf *m, struct ipq *q) +{ + struct label *label; + int result; + + label = mac_mbuf_to_label(m); + + result = 1; + MAC_BOOLEAN(ipq_match, &&, m, label, q, q->ipq_label); + + return (result); +} + +void +mac_netinet_arp_send(struct ifnet *ifp, struct mbuf *m) +{ + struct label *mlabel; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + mlabel = mac_mbuf_to_label(m); + + MAC_IFNET_LOCK(ifp); + MAC_PERFORM(netinet_arp_send, ifp, ifp->if_label, m, mlabel); + MAC_IFNET_UNLOCK(ifp); + splx(s); +} + +void +mac_netinet_icmp_reply(struct mbuf *mrecv, struct mbuf *msend) +{ + struct label *mrecvlabel, *msendlabel; + + mrecvlabel = mac_mbuf_to_label(mrecv); + msendlabel = mac_mbuf_to_label(msend); + + MAC_PERFORM(netinet_icmp_reply, mrecv, mrecvlabel, msend, + msendlabel); +} + +void +mac_netinet_icmp_replyinplace(struct mbuf *m) +{ + struct label *label; + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(netinet_icmp_replyinplace, m, label); +} + +void +mac_netinet_igmp_send(struct ifnet *ifp, struct mbuf *m) +{ + struct label *mlabel; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + mlabel = mac_mbuf_to_label(m); + s = splsoftnet(); + MAC_IFNET_LOCK(ifp); + MAC_PERFORM(netinet_igmp_send, ifp, ifp->if_label, m, mlabel); + MAC_IFNET_UNLOCK(ifp); + splx(s); +} + +void +mac_netinet_tcp_reply(struct mbuf *m) +{ + struct label *label; + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(netinet_tcp_reply, m, label); +} + +void +mac_ipq_update(struct mbuf *m, struct ipq *q) +{ + struct label *label; + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(ipq_update, m, label, q, q->ipq_label); +} + +int +mac_inpcb_check_deliver(struct inpcb *inp, struct mbuf *m) +{ + struct label *label; + int error; + + M_ASSERTPKTHDR(m); + + label = mac_mbuf_to_label(m); + + MAC_CHECK(inpcb_check_deliver, inp, inp->inp_label, m, label); + + return (error); +} + +#if 0 /* XXX PM: Inexistent in Anoubis. */ +int +mac_inpcb_check_visible(struct ucred *cred, struct inpcb *inp) +{ + int error; + + INP_LOCK_ASSERT(inp); + + MAC_CHECK(inpcb_check_visible, cred, inp, inp->inp_label); + + return (error); +} +#endif + +void +mac_inpcb_sosetlabel(struct socket *so, struct inpcb *inp) +{ + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + INP_WLOCK_ASSERT(inp); + SOCK_LOCK_ASSERT(so); + /* XXX PM: The following hook must not sleep. */ + MAC_PERFORM(inpcb_sosetlabel, so, so->so_label, inp, inp->inp_label); + splx(s); +} + +void +mac_netinet_firewall_reply(struct mbuf *mrecv, struct mbuf *msend) +{ + struct label *mrecvlabel, *msendlabel; + + M_ASSERTPKTHDR(mrecv); + M_ASSERTPKTHDR(msend); + + mrecvlabel = mac_mbuf_to_label(mrecv); + msendlabel = mac_mbuf_to_label(msend); + + MAC_PERFORM(netinet_firewall_reply, mrecv, mrecvlabel, msend, + msendlabel); +} + +void +mac_netinet_firewall_send(struct mbuf *m) +{ + struct label *label; + + M_ASSERTPKTHDR(m); + label = mac_mbuf_to_label(m); + MAC_PERFORM(netinet_firewall_send, m, label); +} + +/* + * These functions really should be referencing the syncache structure + * instead of the label. However, due to some of the complexities associated + * with exposing this syncache structure we operate directly on it's label + * pointer. This should be OK since we aren't making any access control + * decisions within this code directly, we are merely allocating and copying + * label storage so we can properly initialize mbuf labels for any packets + * the syncache code might create. + */ +void +mac_syncache_destroy(struct label **label) +{ + + if (*label != NULL) { + MAC_PERFORM(syncache_destroy_label, *label); + mac_labelpool_free(*label); + *label = NULL; + } +} + +int +mac_syncache_init(struct label **label) +{ + int error; + + if (mac_labeled & MPC_OBJECT_SYNCACHE) { + *label = mac_labelpool_alloc(M_NOWAIT); + if (*label == NULL) + return (ENOMEM); + /* + * Since we are holding the inpcb locks the policy can not + * allocate policy specific label storage using M_WAITOK. So + * we need to do a MAC_CHECK instead of the typical + * MAC_PERFORM so we can propagate allocation failures back + * to the syncache code. + */ + MAC_CHECK(syncache_init_label, *label, M_NOWAIT); + if (error) { + MAC_PERFORM(syncache_destroy_label, *label); + mac_labelpool_free(*label); + } + return (error); + } else + *label = NULL; + return (0); +} + +void +mac_syncache_create(struct label *label, struct inpcb *inp) +{ + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + INP_WLOCK_ASSERT(inp); + /* XXX PM: The following hook must not sleep. */ + MAC_PERFORM(syncache_create, label, inp); + splx(s); +} + +void +mac_syncache_create_mbuf(struct label *sc_label, struct mbuf *m) +{ + struct label *mlabel; + + M_ASSERTPKTHDR(m); + mlabel = mac_mbuf_to_label(m); + MAC_PERFORM(syncache_create_mbuf, sc_label, m, mlabel); +} diff --git a/sys/security/mac/mac_internal.h b/sys/security/mac/mac_internal.h new file mode 100644 index 0000000..bfcbdc8 --- /dev/null +++ b/sys/security/mac/mac_internal.h @@ -0,0 +1,357 @@ +/* + * Copyright (c) 1999-2002, 2006 Robert N. M. Watson + * Copyright (c) 2001 Ilmar S. Habibulin + * Copyright (c) 2001-2004 Networks Associates Technology, Inc. + * Copyright (c) 2006 nCircle Network Security, Inc. + * Copyright (c) 2006 SPARTA, Inc. + * All rights reserved. + * + * This software was developed by Robert Watson and Ilmar Habibulin for the + * TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was developed by Robert N. M. Watson for the TrustedBSD + * Project under contract to nCircle Network Security, Inc. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_internal.h,v 1.125 2008/08/23 15:26:36 rwatson Exp $ + */ + +#ifndef _SECURITY_MAC_MAC_INTERNAL_H_ +#define _SECURITY_MAC_MAC_INTERNAL_H_ + +#ifndef _KERNEL +#error "no user-serviceable parts inside" +#endif + +/* + * MAC Framework sysctl namespace. + */ +#ifdef SYSCTL_DECL +SYSCTL_DECL(_security_mac); +#endif /* SYSCTL_DECL */ + +/* + * MAC Framework global types and typedefs. + */ +LIST_HEAD(mac_policy_list_head, mac_policy_conf); +#ifdef MALLOC_DECLARE +MALLOC_DECLARE(M_MACTEMP); +#endif + +/* + * MAC labels -- in-kernel storage format. + * + * In general, struct label pointers are embedded in kernel data structures + * representing objects that may be labeled (and protected). Struct label is + * opaque to both kernel services that invoke the MAC Framework and MAC + * policy modules. In particular, we do not wish to encode the layout of the + * label structure into any ABIs. Historically, the slot array contained + * unions of {long, void} but now contains uintptr_t. XXX PM: Not really in + * OpenBSD. :-) See below. + */ +#define MAC_MAX_SLOTS 4 +#define MAC_FLAG_INITIALIZED 0x0000001 /* Is initialized for use. */ +struct label { + int l_flags; + caddr_t l_perpolicy[MAC_MAX_SLOTS]; +}; + +/* + * MAC Framework global variables. + */ +extern struct mac_policy_list_head mac_policy_list; +extern struct mac_policy_list_head mac_static_policy_list; +extern uint64_t mac_labeled; +#if 0 /* XXX PM: Not necessary in OpenBSD. */ +extern struct mtx mac_ifnet_mtx; +#endif + +/* + * MAC Framework infrastructure functions. + */ +int mac_error_select(int error1, int error2); + +void mac_policy_grab_exclusive(void); +void mac_policy_assert_exclusive(void); +void mac_policy_release_exclusive(void); +void mac_policy_list_busy(void); +int mac_policy_list_conditional_busy(void); +void mac_policy_list_unbusy(void); + +struct label *mac_labelpool_alloc(int flags); +void mac_labelpool_free(struct label *label); +void mac_labelpool_init(void); + +void mac_init_label(struct label *label); +void mac_destroy_label(struct label *label); +int mac_check_structmac_consistent(struct mac *mac); +int mac_allocate_slot(void); + +#if 0 /* XXX PM: Not necessary in OpenBSD. */ +#define MAC_IFNET_LOCK(ifp) mtx_lock(&mac_ifnet_mtx) +#define MAC_IFNET_UNLOCK(ifp) mtx_unlock(&mac_ifnet_mtx) +#else +#define MAC_IFNET_LOCK(ifp) (void)ifp +#define MAC_IFNET_UNLOCK(ifp) (void)ifp +#endif + +/* + * MAC Framework per-object type functions. It's not yet clear how the + * namespaces, etc, should work for these, so for now, sort by object type. + */ +struct label *mac_cred_label_alloc(void); +void mac_cred_label_free(struct label *label); +struct label *mac_pipe_label_alloc(void); +void mac_pipe_label_free(struct label *label); +struct label *mac_socket_label_alloc(int flag); +void mac_socket_label_free(struct label *label); +struct label *mac_vnode_label_alloc(void); +void mac_vnode_label_free(struct label *label); + +int mac_cred_check_relabel(struct ucred *cred, struct label *newlabel); +int mac_cred_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen); +int mac_cred_internalize_label(struct label *label, char *string); +void mac_cred_relabel(struct ucred *cred, struct label *newlabel); + +struct label *mac_mbuf_to_label(struct mbuf *m); + +void mac_pipe_copy_label(struct label *src, struct label *dest); +int mac_pipe_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen); +int mac_pipe_internalize_label(struct label *label, char *string); + +int mac_socket_label_set(struct ucred *cred, struct socket *so, + struct label *label); +void mac_socket_copy_label(struct label *src, struct label *dest); +int mac_socket_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen); +int mac_socket_internalize_label(struct label *label, char *string); + +int mac_vnode_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen); +int mac_vnode_internalize_label(struct label *label, char *string); +void mac_vnode_check_mmap_downgrade(struct ucred *cred, struct vnode *vp, + int *prot); +int vn_setlabel(struct vnode *vp, struct label *intlabel, + struct ucred *cred); + +/* + * MAC_CHECK performs the designated check by walking the policy module list + * and checking with each as to how it feels about the request. Note that it + * returns its value via 'error' in the scope of the caller. + */ +#define MAC_CHECK(check, args...) do { \ + struct mac_policy_conf *mpc; \ + int entrycount; \ + \ + error = 0; \ + LIST_FOREACH(mpc, &mac_static_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## check != NULL) \ + error = mac_error_select( \ + mpc->mpc_ops->mpo_ ## check (args), \ + error); \ + } \ + if ((entrycount = mac_policy_list_conditional_busy()) != 0) { \ + LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## check != NULL) \ + error = mac_error_select( \ + mpc->mpc_ops->mpo_ ## check (args), \ + error); \ + } \ + mac_policy_list_unbusy(); \ + } \ +} while (0) + +/* + * MAC_GRANT performs the designated check by walking the policy module list + * and checking with each as to how it feels about the request. Unlike + * MAC_CHECK, it grants if any policies return '0', and otherwise returns + * EPERM. Note that it returns its value via 'error' in the scope of the + * caller. + */ +#define MAC_GRANT(check, args...) do { \ + struct mac_policy_conf *mpc; \ + int entrycount; \ + \ + error = EPERM; \ + LIST_FOREACH(mpc, &mac_static_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## check != NULL) { \ + if (mpc->mpc_ops->mpo_ ## check(args) == 0) \ + error = 0; \ + } \ + } \ + if ((entrycount = mac_policy_list_conditional_busy()) != 0) { \ + LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## check != NULL) { \ + if (mpc->mpc_ops->mpo_ ## check (args) \ + == 0) \ + error = 0; \ + } \ + } \ + mac_policy_list_unbusy(); \ + } \ +} while (0) + +/* + * MAC_BOOLEAN performs the designated boolean composition by walking the + * module list, invoking each instance of the operation, and combining the + * results using the passed C operator. Note that it returns its value via + * 'result' in the scope of the caller, which should be initialized by the + * caller in a meaningful way to get a meaningful result. + */ +#define MAC_BOOLEAN(operation, composition, args...) do { \ + struct mac_policy_conf *mpc; \ + int entrycount; \ + \ + LIST_FOREACH(mpc, &mac_static_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## operation != NULL) \ + result = result composition \ + mpc->mpc_ops->mpo_ ## operation (args); \ + } \ + if ((entrycount = mac_policy_list_conditional_busy()) != 0) { \ + LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## operation != NULL) \ + result = result composition \ + mpc->mpc_ops->mpo_ ## operation \ + (args); \ + } \ + mac_policy_list_unbusy(); \ + } \ +} while (0) + +/* + * MAC_EXTERNALIZE queries each policy to see if it can generate an + * externalized version of a label element by name. Policies declare whether + * they have matched a particular element name, parsed from the string by + * MAC_EXTERNALIZE, and an error is returned if any element is matched by no + * policy. + */ +#define MAC_EXTERNALIZE(type, label, elementlist, outbuf, \ + outbuflen) do { \ + int claimed, first, ignorenotfound, savedlen; \ + char *element_name, *element_temp; \ + struct sbuf sb; \ + \ + error = 0; \ + first = 1; \ + sbuf_new(&sb, outbuf, outbuflen, SBUF_FIXEDLEN); \ + element_temp = elementlist; \ + while ((element_name = strsep(&element_temp, ",")) != NULL) { \ + if (element_name[0] == '?') { \ + element_name++; \ + ignorenotfound = 1; \ + } else \ + ignorenotfound = 0; \ + savedlen = sbuf_len(&sb); \ + if (first) \ + error = sbuf_printf(&sb, "%s/", element_name); \ + else \ + error = sbuf_printf(&sb, ",%s/", element_name); \ + if (error == -1) { \ + error = EINVAL; /* XXX: E2BIG? */ \ + break; \ + } \ + claimed = 0; \ + MAC_CHECK(type ## _externalize_label, label, \ + element_name, &sb, &claimed); \ + if (error) \ + break; \ + if (claimed == 0 && ignorenotfound) { \ + /* Revert last label name. */ \ + sbuf_setpos(&sb, savedlen); \ + } else if (claimed != 1) { \ + error = EINVAL; /* XXX: ENOLABEL? */ \ + break; \ + } else { \ + first = 0; \ + } \ + } \ + sbuf_finish(&sb); \ +} while (0) + +/* + * MAC_INTERNALIZE presents parsed element names and data to each policy to + * see if any is willing to claim it and internalize the label data. If no + * policies match, an error is returned. + */ +#define MAC_INTERNALIZE(type, label, instring) do { \ + char *element, *element_name, *element_data; \ + int claimed; \ + \ + error = 0; \ + element = instring; \ + while ((element_name = strsep(&element, ",")) != NULL) { \ + element_data = element_name; \ + element_name = strsep(&element_data, "/"); \ + if (element_data == NULL) { \ + error = EINVAL; \ + break; \ + } \ + claimed = 0; \ + MAC_CHECK(type ## _internalize_label, label, \ + element_name, element_data, &claimed); \ + if (error) \ + break; \ + if (claimed != 1) { \ + /* XXXMAC: Another error here? */ \ + error = EINVAL; \ + break; \ + } \ + } \ +} while (0) + +/* + * MAC_PERFORM performs the designated operation by walking the policy module + * list and invoking that operation for each policy. + */ +#define MAC_PERFORM(operation, args...) do { \ + struct mac_policy_conf *mpc; \ + int entrycount; \ + \ + LIST_FOREACH(mpc, &mac_static_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## operation != NULL) \ + mpc->mpc_ops->mpo_ ## operation (args); \ + } \ + if ((entrycount = mac_policy_list_conditional_busy()) != 0) { \ + LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ + if (mpc->mpc_ops->mpo_ ## operation != NULL) \ + mpc->mpc_ops->mpo_ ## operation (args); \ + } \ + mac_policy_list_unbusy(); \ + } \ +} while (0) + +/* XXX PM: These are needed in OpenBSD. */ +#define M_ASSERTPKTHDR(m) KASSERT(m != NULL && m->m_flags & M_PKTHDR); +#define BPFD_LOCK_ASSERT(d) + +#endif /* !_SECURITY_MAC_MAC_INTERNAL_H_ */ diff --git a/sys/security/mac/mac_label.c b/sys/security/mac/mac_label.c new file mode 100644 index 0000000..5c86dae --- /dev/null +++ b/sys/security/mac/mac_label.c @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2003-2004 Networks Associates Technology, Inc. + * Copyright (c) 2007 Robert N. M. Watson + * All rights reserved. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_label.c,v 1.8 2007/02/06 14:19:24 rwatson Exp $; + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +/* + * label_pool is the pool(9) from which most labels are allocated. Label + * structures are initialized to zero bytes so that policies see a NULL/0 + * slot on first use, even if the policy is loaded after the label is + * allocated for an object. + */ +struct pool label_pool; + +int mac_labelpool_ctor(void *, void *, int ); +void mac_labelpool_dtor(void *, void *); + +void +mac_labelpool_init(void) +{ + + pool_init(&label_pool, sizeof(struct label), 0, 0, 0, "mlabelpl", + &pool_allocator_nointr); + pool_setipl(&label_pool, IPL_HIGH); + pool_set_ctordtor(&label_pool, mac_labelpool_ctor, mac_labelpool_dtor, + NULL); +} + +/* + * mac_init_label() and mac_destroy_label() are exported so that they can be + * used in mbuf tag initialization, where labels are not slab allocated from + * the zone_label zone. + */ +void +mac_init_label(struct label *label) +{ + + bzero(label, sizeof(*label)); + label->l_flags = MAC_FLAG_INITIALIZED; +} + +void +mac_destroy_label(struct label *label) +{ + + KASSERT(label->l_flags & MAC_FLAG_INITIALIZED); + +#ifdef DIAGNOSTIC + bzero(label, sizeof(*label)); +#else + label->l_flags &= ~MAC_FLAG_INITIALIZED; +#endif +} + + +int +mac_labelpool_ctor(void *arg, void *object, int flags) +{ + struct label *label = object; + + mac_init_label(label); + return (0); +} + +void +mac_labelpool_dtor(void *arg, void *object) +{ + struct label *label = object; + + mac_destroy_label(label); +} + +struct label * +mac_labelpool_alloc(int flags) +{ +#ifdef DIAGNOSTIC + KASSERT(flags == M_WAITOK || flags == M_NOWAIT); +#endif + /* XXX PM: We use M_* throughout the MAC code (like FreeBSD). */ + return (pool_get(&label_pool, + (flags == M_WAITOK ? PR_WAITOK : PR_NOWAIT))); +} + +void +mac_labelpool_free(struct label *label) +{ + +#ifdef DIAGNOSTIC + /* + * XXX HSH: As soon as all hooks for socket creation are implemented + * XXX HSH: this should go away. + */ + if (label == NULL) { + printf("mac_labelpool_free: no label\n"); + return; + } +#endif + pool_put(&label_pool, label); +} + +/* + * Functions used by policy modules to get and set label values. + */ +caddr_t +mac_label_get(struct label *l, int slot) +{ + + KASSERT(l != NULL); + + return (l->l_perpolicy[slot]); +} + +void +mac_label_set(struct label *l, int slot, caddr_t v) +{ + + KASSERT(l != NULL); + + l->l_perpolicy[slot] = v; +} diff --git a/sys/security/mac/mac_net.c b/sys/security/mac/mac_net.c new file mode 100644 index 0000000..55ce710 --- /dev/null +++ b/sys/security/mac/mac_net.c @@ -0,0 +1,489 @@ +/* + * Copyright (c) 1999-2002 Robert N. M. Watson + * Copyright (c) 2001 Ilmar S. Habibulin + * Copyright (c) 2001-2004 Networks Associates Technology, Inc. + * Copyright (c) 2006 SPARTA, Inc. + * Copyright (c) 2008 Apple Inc. + * All rights reserved. + * + * This software was developed by Robert Watson and Ilmar Habibulin for the + * TrustedBSD Project. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_net.c,v 1.132 2008/08/23 15:26:36 rwatson Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +/* + * XXXRW: struct ifnet locking is incomplete in the network code, so we use + * our own global mutex for struct ifnet. Non-ideal, but should help in the + * SMP environment. XXX PM: Disabled for now. + */ +#if 0 +struct mtx mac_ifnet_mtx; +MTX_SYSINIT(mac_ifnet_mtx, &mac_ifnet_mtx, "mac_ifnet", MTX_DEF); +#endif + +/* XXX PM: These need to be prototyped here in OpenBSD. */ +struct label *mac_bpfdesc_label_alloc(void); +struct label *mac_ifnet_label_alloc(void); +void mac_bpfdesc_label_free(struct label *label); +void mac_ifnet_label_free(struct label *label); +void mac_ifnet_copy_label(struct label *src, struct label *dest); +int mac_ifnet_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen); +int mac_ifnet_internalize_label(struct label *label, char *string); + +/* + * Retrieve the label associated with an mbuf by searching for the tag. + * Depending on the value of mac_labelmbufs, it's possible that a label will + * not be present, in which case NULL is returned. Policies must handle the + * possibility of an mbuf not having label storage if they do not enforce + * early loading. + */ +struct label * +mac_mbuf_to_label(struct mbuf *m) +{ + struct m_tag *tag; + struct label *label; + + if (m == NULL) + return (NULL); + tag = m_tag_find(m, PACKET_TAG_MACLABEL, NULL); + if (tag == NULL) + return (NULL); + label = (struct label *)(tag+1); + return (label); +} + +struct label * +mac_bpfdesc_label_alloc(void) +{ + struct label *label; + + label = mac_labelpool_alloc(M_WAITOK); + MAC_PERFORM(bpfdesc_init_label, label); + return (label); +} + +void +mac_bpfdesc_init(struct bpf_d *d) +{ + + if (mac_labeled & MPC_OBJECT_BPFDESC) + d->bd_label = mac_bpfdesc_label_alloc(); + else + d->bd_label = NULL; +} + +struct label * +mac_ifnet_label_alloc(void) +{ + struct label *label; + + label = mac_labelpool_alloc(M_WAITOK); + MAC_PERFORM(ifnet_init_label, label); + return (label); +} + +void +mac_ifnet_init(struct ifnet *ifp) +{ + + if (mac_labeled & MPC_OBJECT_IFNET) + ifp->if_label = mac_ifnet_label_alloc(); + else + ifp->if_label = NULL; +} + +int +mac_mbuf_tag_init(struct m_tag *tag, int flag) +{ + struct label *label; + int error; + + label = (struct label *) (tag + 1); + mac_init_label(label); + + MAC_CHECK(mbuf_init_label, label, flag); + if (error) { + MAC_PERFORM(mbuf_destroy_label, label); + mac_destroy_label(label); + } + return (error); +} + +int +mac_mbuf_init(struct mbuf *m, int flag) +{ + struct m_tag *tag; + int error; + + M_ASSERTPKTHDR(m); + + if (mac_labeled & MPC_OBJECT_MBUF) { + tag = m_tag_get(PACKET_TAG_MACLABEL, sizeof(struct label), + flag); + if (tag == NULL) + return (ENOMEM); + error = mac_mbuf_tag_init(tag, flag); + if (error) { +#if 0 /* XXX PM: No m_tag_free() in OpenBSD. */ + m_tag_free(tag); +#else + free(tag, M_PACKET_TAGS); +#endif + return (error); + } + m_tag_prepend(m, tag); + } + return (0); +} + +void +mac_bpfdesc_label_free(struct label *label) +{ + + MAC_PERFORM(bpfdesc_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_bpfdesc_destroy(struct bpf_d *d) +{ + + if (d->bd_label != NULL) { + mac_bpfdesc_label_free(d->bd_label); + d->bd_label = NULL; + } +} + +void +mac_ifnet_label_free(struct label *label) +{ + + MAC_PERFORM(ifnet_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_ifnet_destroy(struct ifnet *ifp) +{ + + if (ifp->if_label != NULL) { + mac_ifnet_label_free(ifp->if_label); + ifp->if_label = NULL; + } +} + +void +mac_mbuf_tag_destroy(struct m_tag *tag) +{ + struct label *label; + + label = (struct label *)(tag+1); + + MAC_PERFORM(mbuf_destroy_label, label); + mac_destroy_label(label); +} + +/* + * mac_mbuf_tag_copy is called when an mbuf header is duplicated, in which + * case the labels must also be duplicated. + */ +void +mac_mbuf_tag_copy(struct m_tag *src, struct m_tag *dest) +{ + struct label *src_label, *dest_label; + + src_label = (struct label *)(src+1); + dest_label = (struct label *)(dest+1); + + /* + * mac_mbuf_tag_init() is called on the target tag in m_tag_copy(), + * so we don't need to call it here. + */ + MAC_PERFORM(mbuf_copy_label, src_label, dest_label); +} + +void +mac_mbuf_copy(struct mbuf *m_from, struct mbuf *m_to) +{ + struct label *src_label, *dest_label; + + src_label = mac_mbuf_to_label(m_from); + dest_label = mac_mbuf_to_label(m_to); + + MAC_PERFORM(mbuf_copy_label, src_label, dest_label); +} + +void +mac_ifnet_copy_label(struct label *src, struct label *dest) +{ + int s; /* XXX PM: Enforce IPL_SOFNET for extra paranoia. */ + s = splsoftnet(); + MAC_PERFORM(ifnet_copy_label, src, dest); + splx(s); +} + +int +mac_ifnet_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen) +{ + int error; + + MAC_EXTERNALIZE(ifnet, label, elements, outbuf, outbuflen); + + return (error); +} + +int +mac_ifnet_internalize_label(struct label *label, char *string) +{ + int error; + + MAC_INTERNALIZE(ifnet, label, string); + + return (error); +} + +void +mac_ifnet_create(struct ifnet *ifp) +{ + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + MAC_IFNET_LOCK(ifp); + MAC_PERFORM(ifnet_create, ifp, ifp->if_label); + MAC_IFNET_UNLOCK(ifp); + splx(s); +} + +void +mac_bpfdesc_create(struct ucred *cred, struct bpf_d *d) +{ + + MAC_PERFORM(bpfdesc_create, cred, d, d->bd_label); +} + +/* XXX PM: Already called at IPL_SOFTNET. */ +void +mac_bpfdesc_create_mbuf(struct bpf_d *d, struct mbuf *m) +{ + struct label *label; + + BPFD_LOCK_ASSERT(d); + + label = mac_mbuf_to_label(m); + + MAC_PERFORM(bpfdesc_create_mbuf, d, d->bd_label, m, label); +} + +void +mac_ifnet_create_mbuf(struct ifnet *ifp, struct mbuf *m) +{ + struct label *label; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + s = splsoftnet(); + label = mac_mbuf_to_label(m); + + MAC_IFNET_LOCK(ifp); + MAC_PERFORM(ifnet_create_mbuf, ifp, ifp->if_label, m, label); + MAC_IFNET_UNLOCK(ifp); + splx(s); +} + +int +mac_bpfdesc_check_receive(struct bpf_d *d, struct ifnet *ifp) +{ + int error; + int s; /* XXX PM: Enforce IPL_NET for extra paranoia. */ + s = splnet(); + BPFD_LOCK_ASSERT(d); + + MAC_IFNET_LOCK(ifp); + MAC_CHECK(bpfdesc_check_receive, d, d->bd_label, ifp, ifp->if_label); + MAC_IFNET_UNLOCK(ifp); + splx(s); + + return (error); +} + +int +mac_ifnet_check_transmit(struct ifnet *ifp, struct mbuf *m) +{ + struct label *label; + int error; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + M_ASSERTPKTHDR(m); + s = splsoftnet(); + label = mac_mbuf_to_label(m); + + MAC_IFNET_LOCK(ifp); + MAC_CHECK(ifnet_check_transmit, ifp, ifp->if_label, m, label); + MAC_IFNET_UNLOCK(ifp); + splx(s); + + return (error); +} + +int +mac_ifnet_ioctl_get(struct ucred *cred, struct ifreq *ifr, + struct ifnet *ifp) +{ + char *elements, *buffer; + struct label *intlabel; + struct mac mac; + int error; + + if (!(mac_labeled & MPC_OBJECT_IFNET)) + return (EINVAL); + + error = copyin(ifr->ifr_ifru.ifru_data, &mac, sizeof(mac)); + if (error) + return (error); + + error = mac_check_structmac_consistent(&mac); + if (error) + return (error); + + elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK); + error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL); + if (error) { + free(elements, M_MACTEMP); + return (error); + } + + buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO); + intlabel = mac_ifnet_label_alloc(); + MAC_IFNET_LOCK(ifp); + mac_ifnet_copy_label(ifp->if_label, intlabel); + MAC_IFNET_UNLOCK(ifp); + error = mac_ifnet_externalize_label(intlabel, elements, buffer, + mac.m_buflen); + mac_ifnet_label_free(intlabel); + if (error == 0) + error = copyout(buffer, mac.m_string, strlen(buffer)+1); + + free(buffer, M_MACTEMP); + free(elements, M_MACTEMP); + + return (error); +} + +int +mac_ifnet_ioctl_set(struct ucred *cred, struct ifreq *ifr, struct ifnet *ifp) +{ + struct label *intlabel; + struct mac mac; + char *buffer; + int error; + int s; /* XXX PM: Enforce IPL_SOFTNET for extra paranoia. */ + + if (!(mac_labeled & MPC_OBJECT_IFNET)) + return (EINVAL); + + error = copyin(ifr->ifr_ifru.ifru_data, &mac, sizeof(mac)); + if (error) + return (error); + + error = mac_check_structmac_consistent(&mac); + if (error) + return (error); + + buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK); + error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL); + if (error) { + free(buffer, M_MACTEMP); + return (error); + } + + intlabel = mac_ifnet_label_alloc(); + error = mac_ifnet_internalize_label(intlabel, buffer); + free(buffer, M_MACTEMP); + if (error) { + mac_ifnet_label_free(intlabel); + return (error); + } + + /* + * XXX: Note that this is a redundant privilege check, since policies + * impose this check themselves if required by the policy + * Eventually, this should go away. + */ + error = priv_check_cred(cred, PRIV_NET_SETIFMAC, 0); + if (error) { + mac_ifnet_label_free(intlabel); + return (error); + } + + s = splsoftnet(); /* XXX PM */ + MAC_IFNET_LOCK(ifp); + MAC_CHECK(ifnet_check_relabel, cred, ifp, ifp->if_label, intlabel); + if (error) { + MAC_IFNET_UNLOCK(ifp); + splx(s); /* XXX PM */ + mac_ifnet_label_free(intlabel); + return (error); + } + + MAC_PERFORM(ifnet_relabel, cred, ifp, ifp->if_label, intlabel); + MAC_IFNET_UNLOCK(ifp); + splx(s); /* XXX PM */ + + mac_ifnet_label_free(intlabel); + return (0); +} diff --git a/sys/security/mac/mac_pipe.c b/sys/security/mac/mac_pipe.c new file mode 100644 index 0000000..0f23df0 --- /dev/null +++ b/sys/security/mac/mac_pipe.c @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2002-2003 Networks Associates Technology, Inc. + * Copyright (c) 2006 SPARTA, Inc. + * All rights reserved. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: mac_pipe.c,v 1.114 2008/08/23 15:26:36 rwatson Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +/* XXX PM: These need to be prototyped here in OpenBSD. */ +void mac_pipe_relabel(struct ucred *cred, struct pipepair *pp, + struct label *newlabel); +int mac_pipe_check_relabel(struct ucred *cred, struct pipepair *pp, + struct label *newlabel); + +struct label * +mac_pipe_label_alloc(void) +{ + struct label *label; + + label = mac_labelpool_alloc(M_WAITOK); + MAC_PERFORM(pipe_init_label, label); + return (label); +} + +void +mac_pipe_init(struct pipepair *pp) +{ + + if (mac_labeled & MPC_OBJECT_PIPE) + pp->pp_label = mac_pipe_label_alloc(); + else + pp->pp_label = NULL; +} + +void +mac_pipe_label_free(struct label *label) +{ + + MAC_PERFORM(pipe_destroy_label, label); + mac_labelpool_free(label); +} + +void +mac_pipe_destroy(struct pipepair *pp) +{ + + if (pp->pp_label != NULL) { + mac_pipe_label_free(pp->pp_label); + pp->pp_label = NULL; + } +} + +void +mac_pipe_copy_label(struct label *src, struct label *dest) +{ + + MAC_PERFORM(pipe_copy_label, src, dest); +} + +int +mac_pipe_externalize_label(struct label *label, char *elements, + char *outbuf, size_t outbuflen) +{ + int error; + + MAC_EXTERNALIZE(pipe, label, elements, outbuf, outbuflen); + + return (error); +} + +int +mac_pipe_internalize_label(struct label *label, char *string) +{ + int error; + + MAC_INTERNALIZE(pipe, label, string); + + return (error); +} + +void +mac_pipe_create(struct ucred *cred, struct pipepair *pp) +{ + + MAC_PERFORM(pipe_create, cred, pp, pp->pp_label); +} + +void +mac_pipe_relabel(struct ucred *cred, struct pipepair *pp, + struct label *newlabel) +{ + + MAC_PERFORM(pipe_relabel, cred, pp, pp->pp_label, newlabel); +} + +int +mac_pipe_check_ioctl(struct ucred *cred, struct pipepair *pp, + unsigned long cmd, void *data) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_ioctl, cred, pp, pp->pp_label, cmd, data); + + return (error); +} + +int +mac_pipe_check_poll(struct ucred *cred, struct pipepair *pp) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_poll, cred, pp, pp->pp_label); + + return (error); +} + +int +mac_pipe_check_read(struct ucred *cred, struct pipepair *pp) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_read, cred, pp, pp->pp_label); + + return (error); +} + +int +mac_pipe_check_relabel(struct ucred *cred, struct pipepair *pp, + struct label *newlabel) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_relabel, cred, pp, pp->pp_label, newlabel); + + return (error); +} + +int +mac_pipe_check_stat(struct ucred *cred, struct pipepair *pp) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_stat, cred, pp, pp->pp_label); + + return (error); +} + +int +mac_pipe_check_write(struct ucred *cred, struct pipepair *pp) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + MAC_CHECK(pipe_check_write, cred, pp, pp->pp_label); + + return (error); +} + +int +mac_pipe_label_set(struct ucred *cred, struct pipepair *pp, + struct label *label) +{ + int error; + +#if 0 /* XXX PM: Not necessary. */ + mtx_assert(&pp->pp_mtx, MA_OWNED); +#endif + + error = mac_pipe_check_relabel(cred, pp, label); + if (error) + return (error); + + mac_pipe_relabel(cred, pp, label); + + return (0); +} diff --git a/sys/security/mac/mac_policy.h b/sys/security/mac/mac_policy.h new file mode 100644 index 0000000..ade4f1d --- /dev/null +++ b/sys/security/mac/mac_policy.h @@ -0,0 +1,1078 @@ +/*- + * Copyright (c) 1999-2002, 2007 Robert N. M. Watson + * Copyright (c) 2001-2005 Networks Associates Technology, Inc. + * Copyright (c) 2005-2006 SPARTA, Inc. + * All rights reserved. + * + * This software was developed by Robert Watson for the TrustedBSD Project. + * + * This software was developed for the FreeBSD Project in part by Network + * Associates Laboratories, the Security Research Division of Network + * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), + * as part of the DARPA CHATS research program. + * + * This software was enhanced by SPARTA ISSO under SPAWAR contract + * N66001-04-C-6019 ("SEFOS"). + * + * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * $FreeBSD: src/sys/security/mac/mac_policy.h,v 1.110 2008/06/27 05:39:04 jhb Exp $ + */ +/* + * Kernel interface for MAC policy modules. + */ +#ifndef _SECURITY_MAC_MAC_POLICY_H_ +#define _SECURITY_MAC_MAC_POLICY_H_ + +#ifndef _KERNEL +#error "no user-serviceable parts inside" +#endif + +/*- + * Pluggable access control policy definition structure. + * + * List of operations that are performed as part of the implementation of a + * MAC policy. Policy implementors declare operations with a mac_policy_ops + * structure, and using the MAC_POLICY_SET() macro. If an entry point is not + * declared, then the policy will be ignored during evaluation of that + * event or check. + * + * Operations are sorted first by general class of operation, then + * alphabetically. + */ +#ifdef ACL +#include +#endif + +struct bpf_d; +struct cdev; +struct componentname; +struct ifnet; +struct exec_package; +struct inpcb; +struct ipq; +struct label; +struct mac_policy_conf; +struct mbuf; +struct mount; +struct msg; +struct msqid_kernel; +struct nameidata; +struct pipepair; +struct proc; +struct sbuf; +struct semid_kernel; +struct shmfd; +struct shmid_kernel; +struct sockaddr; +struct socket; +struct ucred; +struct uio; +struct vattr; +struct vnode; +struct sys___sysctl_args; + +/* + * Flags for mpc_labeled declaring which objects should have labels allocated + * for them by the MAC Framework. + */ +#define MPC_OBJECT_CRED 0x0000000000000001 +#define MPC_OBJECT_PROC 0x0000000000000002 +#define MPC_OBJECT_VNODE 0x0000000000000004 +#define MPC_OBJECT_INPCB 0x0000000000000008 +#define MPC_OBJECT_SOCKET 0x0000000000000010 +#define MPC_OBJECT_DEVFS 0x0000000000000020 +#define MPC_OBJECT_MBUF 0x0000000000000040 +#define MPC_OBJECT_IPQ 0x0000000000000080 +#define MPC_OBJECT_IFNET 0x0000000000000100 +#define MPC_OBJECT_BPFDESC 0x0000000000000200 +#define MPC_OBJECT_PIPE 0x0000000000000400 +#define MPC_OBJECT_MOUNT 0x0000000000000800 +#define MPC_OBJECT_POSIXSEM 0x0000000000001000 +#define MPC_OBJECT_POSIXSHM 0x0000000000002000 +#define MPC_OBJECT_SYSVMSG 0x0000000000004000 +#define MPC_OBJECT_SYSVMSQ 0x0000000000008000 +#define MPC_OBJECT_SYSVSEM 0x0000000000010000 +#define MPC_OBJECT_SYSVSHM 0x0000000000020000 +#define MPC_OBJECT_SYNCACHE 0x0000000000040000 +#define MPC_OBJECT_IP6Q 0x0000000000080000 + +/* + * Policy module operations. + */ +typedef void (*mpo_destroy_t)(struct mac_policy_conf *mpc); +typedef void (*mpo_init_t)(struct mac_policy_conf *mpc); + +/* + * General policy-directed security system call so that policies may + * implement new services without reserving explicit system call numbers. + */ +typedef int (*mpo_syscall_t)(struct proc *p, int call, void *arg); + +/* + * Place-holder function pointers for ABI-compatibility purposes. + */ +typedef void (*mpo_placeholder_t)(void); + +/* + * Operations sorted alphabetically by primary object type and then method. + */ +typedef int (*mpo_bpfdesc_check_receive_t)(struct bpf_d *d, + struct label *dlabel, struct ifnet *ifp, + struct label *ifplabel); +typedef void (*mpo_bpfdesc_create_t)(struct ucred *cred, + struct bpf_d *d, struct label *dlabel); +typedef void (*mpo_bpfdesc_create_mbuf_t)(struct bpf_d *d, + struct label *dlabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_bpfdesc_destroy_label_t)(struct label *label); +typedef void (*mpo_bpfdesc_init_label_t)(struct label *label); + +#ifdef ANOUBIS +typedef int (*mpo_check_follow_link)(struct nameidata *, char *, int); +#endif + +typedef int (*mpo_cred_check_relabel_t)(struct ucred *cred, + struct label *newlabel); +typedef int (*mpo_cred_check_visible_t)(struct ucred *cr1, + struct ucred *cr2); +typedef void (*mpo_cred_copy_label_t)(struct label *src, + struct label *dest); +typedef void (*mpo_cred_destroy_label_t)(struct label *label); +typedef int (*mpo_cred_externalize_label_t)(struct label *label, + char *element_name, struct sbuf *sb, int *claimed); +typedef void (*mpo_cred_init_label_t)(struct label *label); +typedef int (*mpo_cred_internalize_label_t)(struct label *label, + char *element_name, char *element_data, int *claimed); +typedef void (*mpo_cred_relabel_t)(struct ucred *cred, + struct label *newlabel); +typedef void (*mpo_cred_create_init_t)(struct ucred *cred); +typedef void (*mpo_cred_create_swapper_t)(struct ucred *cred); + +#ifdef ANOUBIS +typedef int (*mpo_execve_prepare_t)(struct exec_package *, struct label *); +typedef void (*mpo_execve_success_t)(struct exec_package *, struct label *); +#endif + +typedef int (*mpo_ifnet_check_relabel_t)(struct ucred *cred, + struct ifnet *ifp, struct label *ifplabel, + struct label *newlabel); +typedef int (*mpo_ifnet_check_transmit_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_ifnet_copy_label_t)(struct label *src, + struct label *dest); +typedef void (*mpo_ifnet_create_t)(struct ifnet *ifp, + struct label *ifplabel); +typedef void (*mpo_ifnet_create_mbuf_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_ifnet_destroy_label_t)(struct label *label); +typedef int (*mpo_ifnet_externalize_label_t)(struct label *label, + char *element_name, struct sbuf *sb, int *claimed); +typedef void (*mpo_ifnet_init_label_t)(struct label *label); +typedef int (*mpo_ifnet_internalize_label_t)(struct label *label, + char *element_name, char *element_data, int *claimed); +typedef void (*mpo_ifnet_relabel_t)(struct ucred *cred, struct ifnet *ifp, + struct label *ifplabel, struct label *newlabel); + +typedef int (*mpo_inpcb_check_deliver_t)(struct inpcb *inp, + struct label *inplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_inpcb_create_t)(struct socket *so, + struct label *solabel, struct inpcb *inp, + struct label *inplabel); +typedef void (*mpo_inpcb_create_mbuf_t)(struct inpcb *inp, + struct label *inplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_inpcb_destroy_label_t)(struct label *label); +typedef int (*mpo_inpcb_init_label_t)(struct label *label, int flag); +typedef void (*mpo_inpcb_sosetlabel_t)(struct socket *so, + struct label *label, struct inpcb *inp, + struct label *inplabel); + +typedef void (*mpo_ipq_create_t)(struct mbuf *m, struct label *mlabel, + struct ipq *q, struct label *qlabel); +typedef void (*mpo_ipq_destroy_label_t)(struct label *label); +typedef int (*mpo_ipq_init_label_t)(struct label *label, int flag); +typedef int (*mpo_ipq_match_t)(struct mbuf *m, struct label *mlabel, + struct ipq *q, struct label *qlabel); +typedef void (*mpo_ipq_reassemble)(struct ipq *q, struct label *qlabel, + struct mbuf *m, struct label *mlabel); +typedef void (*mpo_ipq_update_t)(struct mbuf *m, struct label *mlabel, + struct ipq *q, struct label *qlabel); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +typedef int (*mpo_kenv_check_dump_t)(struct ucred *cred); +typedef int (*mpo_kenv_check_get_t)(struct ucred *cred, char *name); +typedef int (*mpo_kenv_check_set_t)(struct ucred *cred, char *name, + char *value); +typedef int (*mpo_kenv_check_unset_t)(struct ucred *cred, char *name); + +typedef int (*mpo_kld_check_load_t)(struct ucred *cred, struct vnode *vp, + struct label *vplabel); +typedef int (*mpo_kld_check_stat_t)(struct ucred *cred); +#endif +typedef void (*mpo_mbuf_copy_label_t)(struct label *src, + struct label *dest); +typedef void (*mpo_mbuf_destroy_label_t)(struct label *label); +typedef int (*mpo_mbuf_init_label_t)(struct label *label, int flag); + +typedef int (*mpo_mount_check_stat_t)(struct ucred *cred, + struct mount *mp, struct label *mplabel); +typedef void (*mpo_mount_create_t)(struct ucred *cred, struct mount *mp, + struct label *mplabel); +typedef void (*mpo_mount_destroy_label_t)(struct label *label); +typedef void (*mpo_mount_init_label_t)(struct label *label); +#if 0 /* XXX PM: AppleTalk is deprecated, we don't implement it in OpenBSD. */ +typedef void (*mpo_netatalk_aarp_send_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +#endif +typedef void (*mpo_netinet_arp_send_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_netinet_firewall_reply_t)(struct mbuf *mrecv, + struct label *mrecvlabel, struct mbuf *msend, + struct label *msendlabel); +typedef void (*mpo_netinet_firewall_send_t)(struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_netinet_fragment_t)(struct mbuf *m, + struct label *mlabel, struct mbuf *frag, + struct label *fraglabel); +typedef void (*mpo_netinet_icmp_reply_t)(struct mbuf *mrecv, + struct label *mrecvlabel, struct mbuf *msend, + struct label *msendlabel); +typedef void (*mpo_netinet_icmp_replyinplace_t)(struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_netinet_igmp_send_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +typedef void (*mpo_netinet_tcp_reply_t)(struct mbuf *m, + struct label *mlabel); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +typedef void (*mpo_netinet6_nd6_send_t)(struct ifnet *ifp, + struct label *ifplabel, struct mbuf *m, + struct label *mlabel); +#endif +typedef int (*mpo_pipe_check_ioctl_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel, + unsigned long cmd, void *data); +typedef int (*mpo_pipe_check_poll_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel); +typedef int (*mpo_pipe_check_read_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel); +typedef int (*mpo_pipe_check_relabel_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel, + struct label *newlabel); +typedef int (*mpo_pipe_check_stat_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel); +typedef int (*mpo_pipe_check_write_t)(struct ucred *cred, + struct pipepair *pp, struct label *pplabel); +typedef void (*mpo_pipe_copy_label_t)(struct label *src, + struct label *dest); +typedef void (*mpo_pipe_create_t)(struct ucred *cred, struct pipepair *pp, + struct label *pplabel); +typedef void (*mpo_pipe_destroy_label_t)(struct label *label); +typedef int (*mpo_pipe_externalize_label_t)(struct label *label, + char *element_name, struct sbuf *sb, int *claimed); +typedef void (*mpo_pipe_init_label_t)(struct label *label); +typedef int (*mpo_pipe_internalize_label_t)(struct label *label, + char *element_name, char *element_data, int *claimed); +typedef void (*mpo_pipe_relabel_t)(struct ucred *cred, struct pipepair *pp, + struct label *oldlabel, struct label *newlabel); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +typedef int (*mpo_posixsem_check_getvalue_t)(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks, + struct label *kslabel); +typedef int (*mpo_posixsem_check_open_t)(struct ucred *cred, + struct ksem *ks, struct label *kslabel); +typedef int (*mpo_posixsem_check_post_t)(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks, + struct label *kslabel); +typedef int (*mpo_posixsem_check_stat_t)(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks, + struct label *kslabel); +typedef int (*mpo_posixsem_check_unlink_t)(struct ucred *cred, + struct ksem *ks, struct label *kslabel); +typedef int (*mpo_posixsem_check_wait_t)(struct ucred *active_cred, + struct ucred *file_cred, struct ksem *ks, + struct label *kslabel); +typedef void (*mpo_posixsem_create_t)(struct ucred *cred, + struct ksem *ks, struct label *kslabel); +typedef void (*mpo_posixsem_destroy_label_t)(struct label *label); +typedef void (*mpo_posixsem_init_label_t)(struct label *label); + +typedef int (*mpo_posixshm_check_mmap_t)(struct ucred *cred, + struct shmfd *shmfd, struct label *shmlabel, int prot, + int flags); +typedef int (*mpo_posixshm_check_open_t)(struct ucred *cred, + struct shmfd *shmfd, struct label *shmlabel); +typedef int (*mpo_posixshm_check_stat_t)(struct ucred *active_cred, + struct ucred *file_cred, struct shmfd *shmfd, + struct label *shmlabel); +typedef int (*mpo_posixshm_check_truncate_t)(struct ucred *active_cred, + struct ucred *file_cred, struct shmfd *shmfd, + struct label *shmlabel); +typedef int (*mpo_posixshm_check_unlink_t)(struct ucred *cred, + struct shmfd *shmfd, struct label *shmlabel); +typedef void (*mpo_posixshm_create_t)(struct ucred *cred, + struct shmfd *shmfd, struct label *shmlabel); +typedef void (*mpo_posixshm_destroy_label_t)(struct label *label); +typedef void (*mpo_posixshm_init_label_t)(struct label *label); +#endif + +typedef int (*mpo_priv_check_t)(struct ucred *cred, int priv); +typedef int (*mpo_priv_grant_t)(struct ucred *cred, int priv); + +typedef void (*mpo_cred_associate_nfsd_t)(struct ucred *cred); +typedef int (*mpo_proc_check_debug_t)(struct ucred *cred, + struct proc *p); +typedef int (*mpo_proc_check_sched_t)(struct ucred *cred, + struct proc *p); +#if 0 /* XXX PM: Inexistent in OpenBSD. */ +typedef int (*mpo_proc_check_setaudit_t)(struct ucred *cred, + struct auditinfo *ai); +typedef int (*mpo_proc_check_setaudit_addr_t)(struct ucred *cred, + struct auditinfo_addr *aia); +#endif +typedef int (*mpo_proc_check_setauid_t)(struct ucred *cred, uid_t auid); +typedef int (*mpo_proc_check_setegid_t)(struct ucred *cred, gid_t egid); +typedef int (*mpo_proc_check_seteuid_t)(struct ucred *cred, uid_t euid); +typedef int (*mpo_proc_check_setgid_t)(struct ucred *cred, gid_t gid); +typedef int (*mpo_proc_check_setgroups_t)(struct ucred *cred, int ngroups, + gid_t *gidset); +typedef int (*mpo_proc_check_setregid_t)(struct ucred *cred, gid_t rgid, + gid_t egid); +typedef int (*mpo_proc_check_setresgid_t)(struct ucred *cred, gid_t rgid, + gid_t egid, gid_t sgid); +typedef int (*mpo_proc_check_setresuid