src/acl_test.c

/*
 * Copyright (c) 2001 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 * Test our various libacl functions.
 * Use IRIX semantics or Linux semantics if pertinent.
 */
 
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <getopt.h>
#include <sys/acl.h>

char *prog;
int irixsemantics = 0;

void usage(void)
{
    fprintf(stderr, "usage: %s\n"
           "    -i - use irix semantics\n" 
           ,prog);
           
}

void
print_err(char *msg)
{
    printf("%s: %s: %s\n", prog, msg, strerror(errno));
}

void
dump_ace(acl_entry_t ace)
{
    printf("<tag:%d,id:%d,perm:%u>", 
	    ace->ae_tag, ace->ae_id, ace->ae_perm);
}

void
dump_acl(acl_t acl)
{
    int i;
    printf("ACL[n=%d]: ", acl->acl_cnt);
    for (i=0;i<acl->acl_cnt;i++) {
	acl_entry_t ace = &acl->acl_entry[i];
	printf("%d: ", i);
	dump_ace(ace);
	printf(" ");
    }
    printf("\n");

}

void
dump_acl_by_entry(acl_t acl)
{
    int sts, i;
    acl_entry_t ace; 

    printf("Get 1st entry on filled ACL\n");
    sts = acl_get_entry(acl, ACL_FIRST_ENTRY, &ace);
    printf("acl_get_entry -> %d\n", sts);
    if (sts > 0) {
	printf("1: "); dump_ace(ace); printf("\n");
    }

    for(i=2;i<=acl->acl_cnt+2;i++) {
	printf("Get %dth entry on filled ACL\n", i);
	sts = acl_get_entry(acl, ACL_NEXT_ENTRY, &ace);
	printf("acl_get_entry -> %d\n", sts);
	if (sts > 0) {
	    printf("%d: ",i); dump_ace(ace); printf("\n");
	}
    }
}

/*
 * create a full acl with entries with known bogus values
 */
acl_t
create_filled_acl(void)
{
    acl_t acl;
    int i;

    acl = acl_init(ACL_MAX_ENTRIES);	

    for(i=0;i<ACL_MAX_ENTRIES;i++) {
	acl_entry_t ace = &acl->acl_entry[i];
	ace->ae_tag = i;
	ace->ae_id = i+1;
	ace->ae_perm = i+2;
	acl->acl_cnt++;
    }
    return acl;
}

void
test_acl_get_qualifier(void)
{
    struct acl_entry ace;
    uid_t *uidp;

    printf("*** test out acl_get_qualifier ***\n");

    /* simple ace */
    ace.ae_tag = ACL_USER;
    ace.ae_id = 1;
    ace.ae_perm = 1;

    /* make sure we can get uid and free it */
    uidp = acl_get_qualifier(&ace); 
    printf("uid = %d\n", *uidp);
    acl_free(uidp);

    /* change to another valid tag with a qualifier */
    ace.ae_tag = ACL_GROUP;
    uidp = acl_get_qualifier(&ace); 
    printf("uid = %d\n", *uidp);
    acl_free(uidp);

    /* let's get some errors */

    ace.ae_tag = ACL_USER_OBJ;
    uidp = acl_get_qualifier(&ace); 
    if (uidp == NULL)
	printf("uidp is NULL: %s\n", strerror(errno));
    else
	printf("Error: uidp is NOT NULL\n");

    uidp = acl_get_qualifier(NULL); 
    if (uidp == NULL)
	printf("uidp is NULL: %s\n", strerror(errno));
    else
	printf("Error: uidp is NOT NULL\n");
}

int
main(int argc, char **argv)
{
	int c, i;
	acl_t acl1, acl2, acl3;
	acl_entry_t ace1;
	char *p;

	prog = argv[0];
	for (p = prog; *p; p++) {
		if (*p == '/') {
			prog = p + 1;
		}
	}

	while ((c = getopt(argc, argv, "i")) != -1) {
		switch (c) {
		case 'i':
			irixsemantics = 1;
			break;
		case '?':
                        usage();
			return 1;
		}
	}

	if (irixsemantics) {
	    acl_set_compat(ACL_COMPAT_IRIXGET);
	}

        /* ---------------------------------------------- */
        printf("*** test out creating an ACL ***\n");

	printf("Test acl_init(ACL_MAX_ENTRIES+1)\n");
	acl1 = acl_init(ACL_MAX_ENTRIES+1);
	if (acl1 == NULL) {
	    print_err("acl_init(max+1)");
	}
	printf("Test acl_init(-1)\n");
	acl1 = acl_init(-1);
	if (acl1 == NULL) {
	    print_err("acl_init(-1)");
	}
	printf("Test acl_init(0)\n");
	acl1 = acl_init(0);
	if (acl1 == NULL) {
	    print_err("acl_init(0)");
	}

	printf("Test acl_create_entry(NULL, ...)\n");
	if (acl_create_entry(NULL, &ace1) == -1) {
	    print_err("acl_create_entry(NULL,ace1)");
	}
	printf("Test acl_create_entry(..., NULL)\n");
	if (acl_create_entry(&acl1, NULL) == -1) {
	    print_err("acl_create_entry(NULL,ace1)");
	}
	printf("Test acl_create_entry(acl1, ace1)\n");
	acl1 = NULL;
	if (acl_create_entry(&acl1, &ace1) == -1) {
	    print_err("acl_create_entry(*null,ace1)");
	}

	acl_free(acl1);
	acl1 = acl_init(0);
	for (i=0;i<=ACL_MAX_ENTRIES+1;i++) {
	    printf("%d: creating ace\n", i);
	    if (acl_create_entry(&acl1, &ace1) == -1) {
		print_err("acl_create_entry");
	    }
	    dump_acl(acl1);
	}

        /* ---------------------------------------------- */
        printf("*** test out getting ACEs ***\n");

	dump_acl_by_entry(acl1);

	printf("dump empty ACL\n");
	acl2 = acl_init(0);
	if (acl2 == NULL) {
	    print_err("acl_init(0)");
	}
	dump_acl_by_entry(acl2);

	printf("fill an ACL with known bogus values\n");
	acl3 = create_filled_acl();	
	dump_acl_by_entry(acl3);

        /* ---------------------------------------------- */
        printf("*** test out ACL to text for empty ACL***\n");
	{
	    char *text;
	    ssize_t len;
	    acl_t empty_acl = acl_init(0);
	    text = acl_to_text(empty_acl, NULL); 
            printf("acl_to_text(empty_acl,NULL) -> \"%s\"\n", text); 
	    text = acl_to_text(empty_acl, &len); 
            printf("acl_to_text(empty_acl,NULL) -> \"%s\", len = %u\n", text, len); 
	    text = acl_to_text(NULL, NULL); 
            printf("acl_to_text(NULL,NULL) -> \"%s\"\n", text==NULL?"NULL":text); 
        }
	/* NOTE: Other tests will test out the text for ACLs with ACEs.
         *       So don't have to test it here.
         *       It is simplest to choose ids not in /etc/passwd /etc/group
         *       which is done already in a script. 
         */

	test_acl_get_qualifier();

	return 0;
}