[Cvs-nserver-commits] CVS: cvs-nserver/acl branch-acl.c,1.1.2.3,1.1.2.4 branch-acl.h,1.1.2.3,1.1.2.4 check_acl.c,1.1.2.4,1.1.2.5 check_acl.h,1.1.2.2,1.1.2.3 check_branch_acl.c,1.1.2.2,1.1.2.3

[Alexey M. <ty...@us...>]

Update of /cvsroot/cvs-nserver/cvs-nserver/acl
In directory usw-pr-cvs1:/tmp/cvs-serv28554

Modified Files:
      Tag: NCLI-1-11-1
	branch-acl.c branch-acl.h check_acl.c check_acl.h 
	check_branch_acl.c 
Log Message:
Saving branch-level ACLs for a single file works now


Index: branch-acl.c
===================================================================
RCS file: /cvsroot/cvs-nserver/cvs-nserver/acl/Attic/branch-acl.c,v
retrieving revision 1.1.2.3
retrieving revision 1.1.2.4
diff -u -d -r1.1.2.3 -r1.1.2.4
--- branch-acl.c	2001/08/29 21:17:16	1.1.2.3
+++ branch-acl.c	2001/09/08 23:09:04	1.1.2.4
@@ -21,7 +21,9 @@
 #include "branch-acl.h"
 
 #include <assert.h>
+#include <errno.h>
 #include <fcntl.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -29,36 +31,51 @@
 #include <unistd.h>
 #endif
 
-
 BRANCH_ACL *
 get_branch_acl (DIR_ACL *dir_acl, char *filename, char *branch)
 {
     BRANCH_ACL * branch_acl;
     struct stat stat_buf;
+    struct stringbuf *acl_filename;
 
-    branch_acl = (BRANCH_ACL*) malloc(sizeof(struct BRANCH_ACL));
+    branch_acl = (BRANCH_ACL*) calloc(1, sizeof(struct BRANCH_ACL));
     if (branch_acl == NULL)
 	return NULL;
 
-    branch_acl->filename = dup_stringbuf(dir_acl->dirname);
+    branch_acl->filename = new_stringbuf(filename);
     if (branch_acl->filename == NULL) {
 	free(branch_acl);
 	return NULL;
     }
 
-    catc_stringbuf(branch_acl->filename, '/');
-    cat_stringbuf(branch_acl->filename, filename);
+    branch_acl->fullpath = dup_stringbuf(dir_acl->dirname);
+    if (branch_acl->fullpath == NULL) {
+	free(branch_acl);
+	return NULL;
+    }
 
-    if (stat(branch_acl->filename->buf, &stat_buf) == -1) {
+    catc_stringbuf(branch_acl->fullpath, '/');
+    cat_stringbuf(branch_acl->fullpath, filename);
+
+    if (stat(branch_acl->fullpath->buf, &stat_buf) == -1) {
+	free(branch_acl);
 	return NULL;
     }
 
     branch_acl->dir_acl = dir_acl;
 
-    branch_acl->user_acls = NULL;
+    /* try to open ACL file, if it exists */
+    acl_filename = dup_stringbuf(dir_acl->dirname);
+    catc_stringbuf(acl_filename, '/');
+    cat_stringbuf(acl_filename, "ACL");
 
     branch_acl->branch = branch;
 
+    if (internal_read_branch_acl_file(acl_filename->buf, branch_acl) != 0) {
+	free(branch_acl);
+	return NULL;
+    }
+
     return branch_acl;
 }
 
@@ -72,7 +89,7 @@
 
     /* no list of users, use default permissions */
     if (branch_acl->user_acls == NULL)
-	return default_branch_perm && perm;
+	return default_branch_perm & perm;
 
     ace = get_user_ace(branch_acl->user_acls, username);
 
@@ -94,32 +111,140 @@
 }
 
 int
+parse_branch_permissions (char *perm_str)
+{
+    if (strcmp(perm_str, "checkin") == 0)
+	return branch_perm_checkin;
+
+    if (strcmp(perm_str, "checkout") == 0)
+	return branch_perm_checkout;
+
+    return -1;
+}
+
+char *
+branch_permissions_string (int perm)
+{
+    if (perm == branch_perm_checkin)
+	return "checkin";
+
+    if (perm == branch_perm_checkout)
+	return "checkout";
+
+    return "invalid";
+}
+
+#define MAX_LINE_SIZE 128
+
+#define EXTRACT_NEXT_LINE(c)       \
+	while (*p && (*p != '\t')) \
+	    p++;                   \
+                                   \
+	if (*p == c)               \
+	    return lineno;         \
+        *p = '\0';                 \
+        p++;
+
+int
+internal_read_branch_acl_file (char *filename, struct BRANCH_ACL *bacl)
+{
+    FILE *acl;
+    char buf[MAX_LINE_SIZE];
+    char *p;
+    int lineno = 1;
+
+    acl = fopen(filename, "r");
+    if (acl == NULL) {
+	if (errno == ENOENT)
+	    return 0;
+	else
+	    return -1;
+    }
+
+    while ((p = fgets(buf, MAX_LINE_SIZE, acl)) != NULL) {
+	int len = strlen(buf);
+	char initial_char;
+	char *filename;
+	char *branch;
+	char *username;
+	char *rights;
+	int perm;
+
+	if (buf[len - 1] != '\n') 
+	    return lineno;
+
+	buf[len - 1] = '\0';
+
+	initial_char = *p++;
+	if (initial_char != ' ')
+	    continue;
+
+	filename = p;
+	EXTRACT_NEXT_LINE('\0');
+	if (bacl && (strcmp(bacl->filename->buf, filename) != 0))
+	    continue;
+
+	branch = p;
+	EXTRACT_NEXT_LINE('\0');
+	if (bacl && (strcmp(bacl->branch, branch) != 0))
+	    continue;
+
+	username = p;
+	EXTRACT_NEXT_LINE('\0');
+	rights = p;
+	EXTRACT_NEXT_LINE('\t');
+	perm = parse_branch_permissions(rights);
+
+	if (bacl) {
+	    struct USER_ACL *new_acl = set_user_ace(bacl->user_acls, username, perm);
+	    if (new_acl == NULL) {
+		fclose(acl);
+		return -1;
+	    }
+	    bacl->user_acls = new_acl;
+	}
+
+	lineno++;
+    }
+
+    if (!feof(acl))
+	return -1;
+
+    if (fclose(acl) == EOF)
+	return -1;
+
+    return 0;
+}
+
+int
 store_branch_acl (BRANCH_ACL *branch_acl)
 {
-    struct stringbuf *tmpfilename;
-    struct stringbuf *line;
+    struct stringbuf *tmpfilename = NULL;
+    struct stringbuf *filename = NULL;
+    struct stringbuf *line = NULL;
     int tmpfd;
     int saved_len;
     USER_ACL *user_acl;
+    int retval = 0;
 
     tmpfilename = dup_stringbuf(branch_acl->dir_acl->dirname);
     if (tmpfilename == NULL)
-	return 0;
+	goto out;
 
     cat_stringbuf(tmpfilename, "/ACL.tmp");
 
+    filename = dup_stringbuf(tmpfilename);
+    if (filename == NULL)
+	goto out;
+    shrink_stringbuf(filename, filename->len - strlen(".tmp"));
+
     line = new_stringbuf("");
-    if (line == NULL) {
-	free_stringbuf(tmpfilename);
-	return 0;
-    }
+    if (line == NULL)
+	goto out;
 
     tmpfd = open(tmpfilename->buf, O_CREAT | O_EXCL | O_WRONLY, 0600);
-    if (tmpfd == -1) {
-	free_stringbuf(tmpfilename);
-	free_stringbuf(line);
-	return 0;
-    }
+    if (tmpfd == -1)
+	goto out;
 
     catc_stringbuf(line, ' ');
     cat_stringbuf(line, branch_acl->filename->buf);
@@ -135,12 +260,10 @@
     while (user_acl != NULL) {
 	cat_stringbuf(line, user_acl->username);
 	catc_stringbuf(line, '\t');
-	cat_stringbuf(line, "rights");
+	cat_stringbuf(line, branch_permissions_string(user_acl->perm));
 	catc_stringbuf(line, '\n');
-	if (write(tmpfd, line->buf, line->len) != line->len) {
-	    close(tmpfd);
-	    return 0;
-	}
+	if (write(tmpfd, line->buf, line->len) != line->len)
+	    goto out;
 
 	shrink_stringbuf(line, saved_len);
 
@@ -148,7 +271,18 @@
     }
 
     if (close(tmpfd) == -1)
-	return 0;
+	goto out;
 
-    return 1;
+    if (rename(tmpfilename->buf, filename->buf) == -1)
+	goto out;
+
+    retval = 1;
+
+ out:
+    close(tmpfd);
+    unlink(tmpfilename->buf);
+    free_stringbuf(tmpfilename);
+    free_stringbuf(filename);
+    free_stringbuf(line);
+    return retval;
 }

Index: branch-acl.h
===================================================================
RCS file: /cvsroot/cvs-nserver/cvs-nserver/acl/Attic/branch-acl.h,v
retrieving revision 1.1.2.3
retrieving revision 1.1.2.4
diff -u -d -r1.1.2.3 -r1.1.2.4
--- branch-acl.h	2001/08/29 21:17:16	1.1.2.3
+++ branch-acl.h	2001/09/08 23:09:04	1.1.2.4
@@ -24,6 +24,7 @@
 #include "stringbuf.h"
 
 struct BRANCH_ACL {
+    stringbuf *fullpath;
     stringbuf *filename;
     char *branch;
     DIR_ACL *dir_acl;
@@ -50,6 +51,11 @@
 			       branch_permission perm);
 
 
+int parse_branch_permissions (char *perm_str);
+char *branch_permissions_string (int perm);
+
 int store_branch_acl (BRANCH_ACL *branch_acl);
+
+int internal_read_branch_acl_file (char *filename, struct BRANCH_ACL *bacl);
 
 #endif

Index: check_acl.c
===================================================================
RCS file: /cvsroot/cvs-nserver/cvs-nserver/acl/Attic/check_acl.c,v
retrieving revision 1.1.2.4
retrieving revision 1.1.2.5
diff -u -d -r1.1.2.4 -r1.1.2.5
--- check_acl.c	2001/08/29 21:17:16	1.1.2.4
+++ check_acl.c	2001/09/08 23:09:04	1.1.2.5
@@ -59,6 +59,10 @@
 
     check_existing_file_acl(top_dir);
 
+    check_parsing_branch_permissions();
+
+    check_reading_acl_file();
+
     check_persistent_file_acl(top_dir);
 
     exit (0);

Index: check_acl.h
===================================================================
RCS file: /cvsroot/cvs-nserver/cvs-nserver/acl/Attic/check_acl.h,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -d -r1.1.2.2 -r1.1.2.3
--- check_acl.h	2001/08/29 21:17:16	1.1.2.2
+++ check_acl.h	2001/09/08 23:09:04	1.1.2.3
@@ -24,6 +24,9 @@
 void check_nonexisting_file_acl (char *top_dir);
 void check_existing_file_acl (char *top_dir);
 
+void check_parsing_branch_permissions (void);
+
+void check_reading_acl_file (void);
 void check_persistent_file_acl (char *top_dir);
 
 #endif /* CHECK_ACL_H */

Index: check_branch_acl.c
===================================================================
RCS file: /cvsroot/cvs-nserver/cvs-nserver/acl/Attic/check_branch_acl.c,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -u -d -r1.1.2.2 -r1.1.2.3
--- check_branch_acl.c	2001/08/29 21:17:16	1.1.2.2
+++ check_branch_acl.c	2001/09/08 23:09:04	1.1.2.3
@@ -20,6 +20,7 @@
 #include "dir-acl.h"
 
 #include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -41,6 +42,18 @@
 
 
 void
+check_reading_acl_file (void)
+{
+    assert(internal_read_branch_acl_file("./test-acl-non-existent.txt", NULL) == 0);
+
+    assert((internal_read_branch_acl_file("./test-acl-non-readable.txt", NULL) == -1) && (errno == EACCES));
+
+    assert(internal_read_branch_acl_file("./test-acl-too-few.txt", NULL) == 1);
+    assert(internal_read_branch_acl_file("./test-acl-too-many.txt", NULL) == 1);
+}
+
+
+void
 check_existing_file_acl (char *top_dir)
 {
     DIR_ACL *topdir_acl;
@@ -54,6 +67,11 @@
     foo_acl = get_branch_acl(topdir_acl, "foo", "trunk");
     assert(foo_acl != NULL);
     assert(foo_acl->dir_acl == topdir_acl);
+    assert(foo_acl->fullpath != NULL);
+    assert(foo_acl->filename != NULL);
+    assert(strcmp(foo_acl->filename->buf, "foo") == 0);
+    assert(foo_acl->branch != NULL);
+    assert(strcmp(foo_acl->branch, "trunk") == 0);
 
     /* default permissions allow to checkin/checkout revision on any branch */
     assert(branch_permission_granted(foo_acl, "vasya", branch_perm_checkout));
@@ -93,6 +111,7 @@
 {
     DIR_ACL *topdir_acl;
     BRANCH_ACL *foo_acl;
+    BRANCH_ACL *bar_acl;
     int new_perm;
 
     topdir_acl = start_acl_traverse(top_dir);
@@ -108,7 +127,34 @@
     new_perm = set_branch_acl(foo_acl, "petya", branch_perm_checkin);
 
     if (!store_branch_acl(foo_acl)) {
-	perror("Storing branch ACLs failed");
+	perror("Storing branch ACLs");
 	exit(1);
     }
+
+    /* read those permissions from disk and check them */
+    bar_acl = get_branch_acl(topdir_acl, "foo", "trunk");
+    assert(bar_acl != NULL);
+
+    assert(branch_permission_granted(bar_acl, "vasya", branch_perm_checkout));
+    assert(!branch_permission_granted(bar_acl, "vasya", branch_perm_checkin));
+
+    assert(!branch_permission_granted(bar_acl, "petya", branch_perm_checkout));
+    assert(branch_permission_granted(bar_acl, "petya", branch_perm_checkin));
+
+}
+
+
+void
+check_parsing_branch_permissions (void)
+{
+    assert(parse_branch_permissions("invalid") == -1);
+
+    assert(parse_branch_permissions("checkin") == branch_perm_checkin);
+
+    assert(parse_branch_permissions("checkout") == branch_perm_checkout);
+
+    assert(strcmp(branch_permissions_string(branch_perm_checkin), "checkin") == 0);
+
+    assert(strcmp(branch_permissions_string(branch_perm_checkout), "checkout") == 0);
+
 }