vatlidak.1.tar

submission/0000700003466600001360000000000012624732101012402 5ustar  vatlidakphdsubmission/src/0000700003466600001360000000000012624732054013200 5ustar  vatlidakphdsubmission/src/f_ops.c0000600003466600001360000003325412624732054014463 0ustar  vatlidakphd/*
 * Filename: src/f_ops.c
 *
 * Description: Implements the file system operations
 *
 * Copyright (C) 2015 V. Atlidakis
 *
 * COMS W4187 Fall 2015, Columbia University
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libgen.h>

#include "parser.h"
#include "f_ops.h"


static inline int is_invalid_filename(const char *filename)
{
	int i;
	char *dup, *token;

	/* assert component length */
	dup = strdup(filename);
	token = strtok(dup, "/");
	if (strlen(token) > COMPONENT_LEN) {
		free(dup);
		goto error;
	}
	while ((token = strtok(NULL, "/")) != NULL)
		if (strlen(token) > COMPONENT_LEN) {
			free(dup);
			goto error;
		}
	free(dup);

	/* assert proper prefix of filename */
	if (filename[0] != '/')
		return NOT_OK;

	if (strncmp(filename, "/home", strlen("/home"))
	    && strncmp(filename, "/tmp", strlen("/tmp")))
		goto error;

	/* assert not more than one consecutive '/' */
	for (i = 0; i < (int)strlen(filename) - 1; i++)
		if (filename[i] == '/' && filename[i+1] == '/')
			goto error;
	return OK;
error:
	return NOT_OK;
}


static inline struct file *f_ops_get_handle(struct file *fs, char *filename)
{
	while (fs != NULL) {
		if (!strcmp(fs->filename, filename))
			break;
		fs = fs->next;
	}
	return fs;
}


static inline struct file *f_ops_get_handle_prev(struct file *fs,
						 char *filename)
{
	while (fs != NULL) {
		if (fs->next)
			if (!strcmp(fs->next->filename, filename))
				break;
		fs = fs->next;
	}
	return fs;
}


static inline struct acl *copy_acls(struct acl **dst, struct acl *src)
{
	struct acl *temp;

	while (src != NULL) {
		temp = calloc(1, sizeof(struct acl));
		if (!temp) {
			perror("calloc");
			goto error;
		}
		temp->user = calloc(strlen(src->user) + 1, sizeof(char));
		temp->group = calloc(strlen(src->group) + 1, sizeof(char));
		if (!temp->user || !temp->group) {
			perror("calloc");
			goto error;
		}
		strcpy(temp->user, src->user);
		strcpy(temp->group, src->group);
		temp->permissions = src->permissions;
		temp->next = NULL;
		/* Append ACL from src (parent) to dst (child) */
		while (*dst)
			dst = &(*dst)->next;
		*dst = temp;
		src = src->next;
	}
	return *dst;
error:
	return NULL;
}


/*
 * Main method doing the ACL checks
 *
 * This method does all the dirty job of iteratively trying to match
 * the user, group, permissions pointed by pacl lwith the ACLs of the
 * file "filename". Basically, checks all the ACLs of the file, and if
 * a matching rule is found returns the rresult.
 */
static int do_f_ops_acl_check(struct file **fs, char *filename,
			      struct acl *pacl)
{
	char *parent, *dup;
	struct file *file_handle;
	struct acl *ptemp;
	struct acl acl;

	file_handle = f_ops_get_handle(*fs, filename);
	if (!file_handle)
		goto error;

	ptemp = file_handle->acls;
	if (!ptemp)
		goto error;

	/* recursively check READ permissions on all predecessors */
	dup = strdup(filename);
	parent = dirname(dup);
	if (!strncmp(parent, "/", strlen(parent)))
		goto no_predecessors_end_recursion;
	if (*parent == '.') {
		fprintf(stderr, "Can't parse parent of: \"%s\"\n", filename);
		free(dup);
		goto error;
	}
	acl.user = pacl->user;
	acl.group = pacl->group;
	acl.permissions = READ;
	if (do_f_ops_acl_check(fs, parent, &acl)) {
		fprintf(stderr, "Parent of: \"%s\" not READable\n", filename);
		free(dup);
		goto error;
	}
no_predecessors_end_recursion:
	free(dup);

	/* All right -- the actual ACLs check is performed here */
	while (ptemp != NULL) {

		/* if user & group match */
		if (!strcmp(ptemp->user, pacl->user)
		    && !strcmp(ptemp->group, pacl->group)) {
			if ((ptemp->permissions & pacl->permissions))
				return OK;
			if (ptemp->permissions == NO_PERMISSION)
				return NOT_OK;
		}
		ptemp = ptemp->next;
	}
	ptemp = file_handle->acls;
	while (ptemp != NULL) {

		/* if user is any user and group matches */
		if (!strcmp(ptemp->user, "*")
		    && !strcmp(ptemp->group, pacl->group)) {
			if ((ptemp->permissions & pacl->permissions))
				return OK;
		}

		/* if group is any group & user matches */
		if (!strcmp(ptemp->group, "*")
		   && !strcmp(ptemp->user, pacl->user)) {
			if ((ptemp->permissions & pacl->permissions))
				return OK;
		}
		ptemp = ptemp->next;
	}
	ptemp = file_handle->acls;
	while (ptemp != NULL) {
		/* if group is any group & user is any user */
		if (!strcmp(ptemp->group, "*") && !strcmp(ptemp->user, "*")) {
			if ((ptemp->permissions & pacl->permissions))
				return OK;
			if (ptemp->permissions == NO_PERMISSION)
				return NOT_OK;
		}
		ptemp = ptemp->next;
	}

error:
	return NOT_OK;
}


/*
 * This method updates the ACLs of a file.
 *
 * Caller must have permissions to set acls and filename must
 * correspond to a valid file -- no checks here (only mem alloc).
 */
static struct file *do_f_ops_acl_set(struct file **fs, char *filename,
				     struct acl *pacl)
{
	struct acl **ppacl;
	struct file *file_handle;

	DEBUG("setting::%s,%s,%s,%d\n", filename, pacl->user, pacl->group,
	      pacl->permissions);

	file_handle = f_ops_get_handle(*fs, filename);
	if (pacl->permissions == INHERIT_FROM_PARENT) {
		if (!copy_acls(&file_handle->acls, file_handle->parent->acls))
			goto error;
		goto out;
	}

	ppacl = &file_handle->acls;
	while (*ppacl != NULL)
		ppacl = &((*ppacl)->next);
	*ppacl = calloc(1, sizeof(struct acl));
	if (!*ppacl) {
		perror("calloc");
		goto error;
	}
	(*ppacl)->permissions = pacl->permissions;
	(*ppacl)->user = calloc(strlen(pacl->user) + 1, sizeof(char));
	if (!(*ppacl)->user) {
		perror("calloc");
		goto error;
	}
	strcpy((*ppacl)->user, pacl->user);

	(*ppacl)->group = calloc(strlen(pacl->group) + 1, sizeof(char));
	if (!(*ppacl)->group) {
		perror("calloc");
		goto error;
	}
	strcpy((*ppacl)->group, pacl->group);
	(*ppacl)->next = NULL;
out:
	return file_handle;
error:
	return NULL;
}


/*
 * This method mounts (initializes) the filesystem, basically by
 * creating /tmp and /home.
 */
static struct file *do_f_ops_mount(struct file **fs)
{
	struct acl acl;
	struct file *file_handle;

	env_is_set = 0;
	*fs = NULL;

	file_handle = calloc(1, sizeof(struct file));
	if (!file_handle) {
		perror("calloc");
		goto error;
	}
	strcpy(file_handle->filename, "/home");
	file_handle->acls = NULL;
	file_handle->parent = NULL;
	file_handle->children = 0;

	file_handle->next = *fs;
	*fs = file_handle;

	acl.user = "*";
	acl.group = "*";
	acl.permissions = READ;
	if (!do_f_ops_acl_set(fs, file_handle->filename, &acl))
		goto error;

	file_handle = calloc(1, sizeof(struct file));
	if (!file_handle) {
		perror("calloc");
		goto error;
	}
	strcpy(file_handle->filename, "/tmp");
	file_handle->acls = NULL;
	file_handle->parent = NULL;
	file_handle->children = 0;

	file_handle->next = *fs;
	*fs = file_handle;

	acl.user = "*";
	acl.group = "*";
	acl.permissions = READ_WRITE;
	if (!do_f_ops_acl_set(fs, file_handle->filename, &acl))
		goto error;

	env_is_set = 1;

	return *fs;
error:
	return NULL;
}


/*
 * This method mounts (initializes) the filesystem, basically by
 * creating /tmp and /home.
 */
static struct file *do_f_ops_unmount(struct file **fs)
{
	struct file *file_handle, *temp;
	struct acl acl;

	memset((char *)&acl, 0, sizeof(struct acl));
	env_is_set = 0;

	file_handle = *fs;
	while (file_handle) {

		temp = file_handle->next;
		f_ops_delete(fs, file_handle->filename, &acl);
		file_handle = temp;

	}

	return *fs;
}


/*
 * This method creates a file in the file system.
 *
 * There is handful of checks before creation of a file:
 * - valid filename
 * - exisiting predecessors
 * - WRITE permision on parent
 * - not existing file
 *
 * If tests succeed file structure is creates and then ACLs are
 * set (i.e., created as will).
 *
 */
static struct file *do_f_ops_create(struct file **fs, char *filename,
				    struct acl *pacl)
{
	int rval;
	char *parent, *dup;
	char _filename[FILENAME_LEN];
	struct acl acl;
	struct file *file_handle;

	dup = strdup(filename);
	parent = dirname(dup);
	if (*parent == '.') {
		fprintf(stderr, "Can't parse parent of: \"%s\"\n", filename);
		goto error;
	}
	if (is_invalid_filename(filename)) {
		fprintf(stderr, "Invalid filename: \"%s\"\n", filename);
		goto error;
	}

	acl.user = pacl->user;
	acl.group = pacl->group;
	/*
	 * if user tries to create home folder, relax restrictions;
	 * but only for home folder. For any other creation WRITE
	 * persmission is required.
	 */
	acl.permissions = WRITE;
	memset(_filename, 0, FILENAME_LEN);
	sprintf(_filename, "/home/%s", acl.user);
	if (!strncmp(_filename, filename, strlen(filename)))
		acl.permissions = READ;
	rval = f_ops_acl_check(fs, parent, &acl);
	if (rval) {
		fprintf(stderr,
			"Parent of: \"%s\" isn't writable from user: \"%s\"\n",
			filename, acl.user);
		goto error;
	}

	if (f_ops_get_handle(*fs, filename)) {
		fprintf(stderr, "File: \"%s\" exists\n", filename);
		goto error;
	}
	/*
	 * Done with tests ;-)
	 */
	file_handle = calloc(1, sizeof(struct file));
	if (!file_handle) {
		perror("calloc");
		goto error;
	}
	strcpy(file_handle->filename, filename);
	file_handle->acls = NULL;
	file_handle->children = 0;
	file_handle->parent = f_ops_get_handle(*fs, parent);
	file_handle->parent->children++;
	file_handle->next = *fs;
	*fs = file_handle;
	free(dup);

	return do_f_ops_acl_set(fs, filename, pacl);
error:
	free(dup);
	return NULL;
}


/*
 * This method deletes an existing file.
 *
 * WRITE permission on the parent is first asserted and then
 * ACL structs are deleted along with the file structure.
 *
 */
static struct file *do_f_ops_delete(struct file **fs, char *filename,
				    struct acl *pacl)
{
	int rval;
	struct acl acl, *temp;
	struct file *file_handle, *prev;
	char *parent, *dup;
	char _filename[FILENAME_LEN];

	dup = strdup(filename);
	parent = dirname(dup);
	if (*parent == '.') {
		fprintf(stderr, "Can't parse parent of: \"%s\"\n", filename);
		goto error;
	}

	/* During unmounting disable checks to allow removing of everything*/
	if (!env_is_set)
		goto relax_checks;

	/* Otherwise, no-one removes /home and /tmp */
	if (!strcmp(filename, "/tmp") || !strcmp(filename, "/home")) {
		fprintf(stderr, "File \"%s\" cannot be removed\n", filename);
		goto error;
	}
	acl.user = pacl->user;
	acl.group = pacl->group;
	/*
	 * if user tries to remove his or her home folder, relax
	 * restrictions; but only for home folder. For any other creation
	 * WRITE persmission is required.
	 */
	acl.permissions = WRITE;
	memset(_filename, 0, FILENAME_LEN);
	sprintf(_filename, "/home/%s", acl.user);
	if (!strncmp(_filename, filename, strlen(filename)))
		acl.permissions = READ;
	rval = f_ops_acl_check(fs, parent, &acl);
	if (rval) {
		fprintf(stderr,
			"Parent of: \"%s\" isn't writable from user: \"%s\"\n",
			filename, acl.user);
		goto error;
	}

relax_checks:
	file_handle = f_ops_get_handle(*fs, filename);
	if (!file_handle) {
		fprintf(stderr, "File: \"%s\" does not exist\n", filename);
		goto error;
	}

	if (file_handle->children)  {
		fprintf(stderr, "File: \"%s\" has children\n", filename);
		goto error;
	}

	/* find previous node and shortcut current */
	prev = *fs;
	while (prev) {
		if (prev->next)
			if (!strcmp(prev->next->filename, filename))
				break;
		prev = prev->next;

	}
	/* if no previous node found, current is at the beginning */
	if (prev)
		prev->next = file_handle->next;
	else
		*fs = file_handle->next;

	if (file_handle->parent)
		file_handle->parent->children--;

	/* free memory */
	while (file_handle->acls) {
		temp = file_handle->acls;
		file_handle->acls = file_handle->acls->next;
		free(temp->user);
		free(temp->group);
		free(temp);
	}
	free(file_handle);
	free(dup);
	return prev != NULL ? prev : *fs;
error:
	free(dup);
	return NULL;
}


/*
 * This method updates (sets) the ACLs of an existing file.
 *
 * Note that this method doesn't check for WRITE permissions
 * since in the parsing loop and update will always be following
 * a create (which asserts write permissions).
 */
static struct file *do_f_ops_update(struct file **fs, char *filename,
				    struct acl *pacl)
{
	struct file *file_handle;

	file_handle = f_ops_get_handle(*fs, filename);
	if (!file_handle) {
		fprintf(stderr, "File: \"%s\" does not exist\n", filename);
		goto error;
	}
	return do_f_ops_acl_set(fs, filename, pacl);
error:
	return NULL;
}


/*
 * Exported interface
 *
 * mount: Initializes the file system (created /home and /tmp)
 * unmount: Deallocated the structs kept in mem.
 * create: Creates a file and adds it in the file system
 * update: Updates the acls of a file
 * check: Check (compares) mathing acl permissions on a file
 * delete: Delete a file from the file system
 */
struct file *f_ops_mount(struct file **fs)
{
	DEBUG("mounting\n");

	return do_f_ops_mount(fs);
}


struct file *f_ops_unmount(struct file **fs)
{
	DEBUG("unmounting\n");

	return do_f_ops_unmount(fs);
}


struct file *f_ops_create(struct file **fs, char *filename,
			  struct acl *pacl)
{
	DEBUG("creating::%s,%s,%s,%d\n", filename, pacl->user,
	      pacl->group, pacl->permissions);

	return  do_f_ops_create(fs, filename, pacl);
}


struct file *f_ops_update(struct file **fs, char *filename,
			  struct acl *pacl)
{
	DEBUG("updating::%s,%s,%s,%d\n", filename, pacl->user,
	      pacl->group, pacl->permissions);

	return do_f_ops_update(fs, filename, pacl);
}


struct file *f_ops_delete(struct file **fs, char *filename,
			  struct acl *pacl)
{
	DEBUG("deleting::%s\n", filename);

	return do_f_ops_delete(fs, filename, pacl);
}


int f_ops_acl_check(struct file **fs, char *filename, struct acl *pacl)
{

	DEBUG("checking::%s,%s,%s,%d\n", filename, pacl->user,
	      pacl->group, pacl->permissions);

	return do_f_ops_acl_check(fs, filename, pacl);
}


int f_ops_invalid_home_folder(struct file **fs, char *username)
{
	char _filename[FILENAME_LEN];

	DEBUG("checking home folder of user:%s\n", username);

	if (!strcmp(username, "*"))
		return OK;

	memset(_filename, 0, FILENAME_LEN);
	sprintf(_filename, "/home/%s", username);
	if (f_ops_get_handle(*fs, _filename))
		return OK;

	return NOT_OK;
}
submission/src/main.c0000600003466600001360000003007012624732054014272 0ustar  vatlidakphd/*
 * Filename: src/main.c
 *
 * Description: Main parsing loop entry-points
 *
 * Copyright (C) 2015 V. Atlidakis
 *
 * COMS W4187 Fall 2015, Columbia University
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "parser.h"
#include "f_ops.h"


int nlines;


#ifdef _DEBUG
static inline void ls(struct file *fs)
{
	fprintf(stderr, "-------\n");
	fprintf(stderr, "#filename:user.group,permissions,children\n");
	while (fs != NULL) {
		struct acl *temp = fs->acls;

		while (temp != NULL) {
			 fprintf(stderr, "%s:%s.%s,%d,%d\n",
				 fs->filename, temp->user,
				 temp->group, temp->permissions,
				 fs->children);
			 temp = temp->next;
		}
		fs = fs->next;
	}
	fprintf(stderr, "-------\n");
}
#endif


static inline int is_invalid_line(const char *line, int max_spaces)
{
	int i, spaces = 0;

	for (i = 0; i < ((int)strlen(line)) - 1; i++)
		if (line[i] == ' ')
			spaces++;
	return spaces > max_spaces ? NOT_OK : OK;
}


static inline void get_at_end_of_command(FILE *input_stream)
{
	size_t n = 12345;
	char *opsline;
	int len;

	while (1) {
		opsline = NULL;
		len = getline(&opsline, &n, input_stream);
		nlines++;
		if (len == -1 || !strcmp(opsline, ".\n"))
			break;
		free(opsline);
	}
	free(opsline);
}


/*
 * parse_user_definition: parses the user definition portion of the file and
 *			  implements the environment setting loop.
 */
static int parse_user_definition_portion(struct file **fs, FILE *input_stream)
{
	int len;
	size_t n = 12345;
	struct file *file_handle;
	struct acl acl_rw, acl_r;
	char *line, *_line, *user,  *group, *filename;

	nlines = 0;
	file_handle = NULL;
	while (1) {
		/* when line is NULL: getline allocates appropriate buffer */
		line = NULL;
		len = getline(&line, &n, input_stream);
		if (len == -1) {
			free(line);
			goto out;
		}

		_line = strdup(line);
		if (_line == NULL) {
			perror("calloc");
			goto out_free_line;
		}
		_line[strlen(line)-1] = '\0';
		nlines++;

		if (len == 2 && strncmp(line, ".\n", 2) == 0)
			goto out_free_line;
		if (is_invalid_line(_line, 1))
			goto error_free_line;
		len = get_user(line, &user, ".\n");
		if (len < 0)
			goto error_free_line;
		len = get_group(NULL, &group, "\n ");
		if (len < 0)
			goto error_free_line;
		len = get_filename(NULL, &filename, "\n");
		if (len < 0 || len > FILENAME_LEN)
			goto error_free_line;

		memset(&acl_rw, 0, sizeof(struct acl));
		acl_rw.user = user;
		acl_rw.group = group;
		acl_rw.permissions = READ_WRITE;

		memset(&acl_r, 0, sizeof(struct acl));
		acl_r.user = "*";
		acl_r.group = "*";
		acl_r.permissions = READ;

		DEBUG("User:%s, Group:%s, Filename:%s, len:%d\n",
		      acl_rw.user, acl_rw.group, filename, len);
		/*
		 * At this point it is quaranteed that we have
		 * proper user, group, and filename (components missing)
		 */
		if (len > 0) {
			file_handle = f_ops_create(fs, filename, &acl_rw);
			if (file_handle) {
				f_ops_update(fs, filename, &acl_r);
				printf("%d\tY\tOK\n", nlines);
			} else {
				printf("%d\tX\tE: "
				       "Failed to create: \"%s\"\n",
				       nlines, filename);
			}
		} else if (!len && file_handle) {
			if (f_ops_invalid_home_folder(fs, user)) {
				printf("%d\tX\tE: "
				       "Failed to update ACLs -- "
				       "no home folder for user \"%s\"\n",
				       nlines, user);
				goto cmd_loop;
			}
			if (f_ops_update(fs, file_handle->filename, &acl_rw))
				printf("%d\tY\tOK\n", nlines);
			else
				printf("%d\tX\tE: "
				       "Failed to update ACLs of: \"%s\"\n",
				       nlines, file_handle->filename);
		}
		goto cmd_loop;
error_free_line:
		printf("%d\tX\tE: Malformed line %s\n", nlines, _line);
cmd_loop:
		free(line);
		free(_line);
	}

out_free_line:
	free(line);
	free(_line);
out:
	return nlines > 1 ? OK : NOT_OK;
}


/*
 * parse_file_operation: parses the file operation portion and implements
 *			 implements the COMMANDs loop.
 */
static int parse_file_operation_portion(struct file **fs, FILE *input_stream)
{
	size_t n = 12345;
	int len, rval, ncmds, error_line;
	struct acl acl_, acl_w, acl_r;
	struct file *file_handle;
	char *cmdline, *_cmdline, *opsline;
	char *cmd, *user, *permissions, *group, *filename;

	ncmds = 0;
	while (1) {
		cmdline = NULL;
		len = getline(&cmdline, &n, input_stream);
		if (len == -1) {
			free(cmdline);
			goto out;
		}
		ncmds++;
		nlines++;
		_cmdline = strdup(cmdline);
		if (_cmdline == NULL) {
			perror("calloc");
			goto out_free_cmd;
		}
		error_line = ncmds;
		_cmdline[strlen(cmdline)-1] = '\0';
		if (is_invalid_line(_cmdline, 2))
			goto error_free_cmd;
		len = get_cmd(cmdline, &cmd, "\n ");
		if (len < 0)
			goto error_free_cmd;
		len = get_user(NULL, &user, "\n.");
		if (len < 0)
			goto error_free_cmd;
		len = get_group(NULL, &group, "\n ");
		if (len < 0)
			goto error_free_cmd;
		len = get_filename(NULL, &filename, "\n");
		if (len < 0 || len > FILENAME_LEN)
			goto error_free_cmd;
		DEBUG("cmd:%s, User:%s, Group:%s, Filename:%s\n",
		      cmd, user, group, filename);

		if (!strcmp(cmd, "READ")) {
			error_line = ncmds;
			acl_r.user = user;
			acl_r.group = group;
			acl_r.permissions = READ;
			rval = f_ops_acl_check(fs, filename, &acl_r);
			if (rval) {
				printf("%d\tN\t%s\tE: ", error_line, _cmdline);
				printf("Cannot to read file\n");
			} else {
				printf("%d\tY\t%s\tOK\n", error_line, _cmdline);
			}
			goto cmd_loop;
		} else if (!strcmp(cmd, "WRITE")) {
			error_line = ncmds;
			acl_w.user = user;
			acl_w.group = group;
			acl_w.permissions = WRITE;
			if (f_ops_acl_check(fs, filename, &acl_w)) {
				printf("%d\tN\t%s\tE: ", error_line, _cmdline);
				printf("Cannot write file\n");
			} else {
				printf("%d\tY\t%s\tOK\n", error_line, _cmdline);
			}
			goto cmd_loop;
		} else if (!strcmp(cmd, "DELETE")) {
			error_line = ncmds;
			acl_w.user = user;
			acl_w.group = group;
			acl_w.permissions = WRITE;
			if (f_ops_acl_check(fs, filename, &acl_w)) {
				printf("%d\tN\t%s\tE: ", error_line, _cmdline);
				printf("Cannot delete file\n");
			} else {
				f_ops_delete(fs, filename, &acl_w);
				printf("%d\tY\t%s\tOK\n", error_line, _cmdline);
			}
			goto cmd_loop;
		} else if (!strcmp(cmd, "CREATE")) {
			/*
			 * CREATE user.group filename
			 *	   user1.group1 permissions
			 *	   user2.group2 permissions
			 *	   ...
			 *	   userN.groupN permissions
			 *	   .
			 */
			file_handle = NULL;
create_loop:
			/* loop consuming lines following CREATE cmd */
			opsline = NULL;
			error_line = nlines;
			len = getline(&opsline, &n, input_stream);
			if (len == -1)
				goto out_free_ops_free_cmd;
			nlines++;
			/* end of a CREATE cmd with NULL ACLs specified*/
			if (len == 2 && !strcmp(opsline, ".\n")
			    && !file_handle) {
				error_line = ncmds;
				acl_.user = user;
				acl_.group = group;
				acl_.permissions = encode("inherit");
				file_handle = f_ops_create(fs, filename, &acl_);
				if (file_handle)
					printf("%d\tY\t%s\tOK\n",
					       error_line, _cmdline);
				else
					printf("%d\tN\t%s\tE: "
					       "Failed to create file\n",
					       error_line, _cmdline);
				free(opsline);
				goto cmd_loop;
			/* end of CREATE cmd with ACLs specified */
			} else if (len == 2 && !strcmp(opsline, ".\n")) {
				error_line = ncmds;
				if (file_handle)
					printf("%d\tY\t%s\tOK\n",
					       ncmds, _cmdline);
				else
					printf("%d\tN\t%s\tE: "
					       "Failed to create file\n",
					       error_line, _cmdline);
				free(opsline);
				goto cmd_loop;
			}
			/* if here, consume a "user.group permissions" line */
			error_line = nlines;
			len = get_user(opsline, &user, ".");
			if (len < 0)
				goto error_free_ops_free_cmd;
			len = get_group(NULL, &group, " ");
			if (len < 0)
				goto error_free_ops_free_cmd;
			len = get_perm(NULL, &permissions, "\n");
			if (len < 0)
				goto error_free_ops_free_cmd;
			acl_.user = user;
			acl_.group = group;
			acl_.permissions = encode(permissions);
			/* create file with ACLs read from stdin */
			if (!file_handle) {
				file_handle = f_ops_create(fs, filename, &acl_);
				free(opsline);
				if (file_handle) {
					printf("%d\tY\tOK\n", error_line);
					goto create_loop;
				} else {
					/*
					 * creation failed the first time but we
					 * still need to consume lines until
					 * reaching the "." line.
					 */
					printf("%d\tN\tE: "
					       "Failed to create file\n",
					       error_line);
					get_at_end_of_command(input_stream);
					goto cmd_loop;
				}
			/* update file with ACLs read from stdin */
			} else {
				if (f_ops_update(fs, filename, &acl_))
					printf("%d\tY\tOK\n", error_line);
				else
					printf("%d\tN\tE: "
					       "Failed to create file\n",
					       error_line);
				free(opsline);
				goto create_loop;
			}
		/* end of CREATE cmd */
		} else if (!strcmp(cmd, "ACL")) {
			/*
			 * ACL user.group filename
			 *	   user1.group1 permissions
			 *	   user2.group2 permissions
			 *	   ...
			 *	   userN.groupN permissions
			 *	   .
			 */
			file_handle = NULL;
			/* loop consuming lines following ACL cmd */
acl_loop:
			opsline = NULL;
			error_line = nlines;
			len = getline(&opsline, &n, input_stream);
			if (len == -1)
				goto out_free_ops_free_cmd;
			nlines++;
			/* end of a CREATE cmd with NULL ACLs specified*/
			if (len == 2 && !strcmp(opsline, ".\n")
			    && !file_handle) {
				error_line = ncmds;
				acl_.user = user;
				acl_.group = group;
				printf("%d\tN\t%s\tE: ", error_line, _cmdline);
				printf("Invalid (null) ACLs for file\n");
				free(opsline);
				goto cmd_loop;
			/* end of CREATE cmd with ACLs specified */
			} else if (len == 2 && !strcmp(opsline, ".\n")) {
				error_line = ncmds;
				if (file_handle)
					printf("%d\tY\t%s\tOK\n",
					       error_line, _cmdline);
				else
					printf("%d\tN\t%s\tE: "
					       "Failed to create file\n",
						error_line, _cmdline);
				free(opsline);
				goto cmd_loop;
			}
			error_line = nlines;
			/* if here, consume a "user.group permissions" line */
			len = get_user(opsline, &user, ".");
			if (len < 0)
				goto error_free_ops_free_cmd;
			len = get_group(NULL, &group, " ");
			if (len < 0)
				goto error_free_ops_free_cmd;
			len = get_perm(NULL, &permissions, "\n");
			if (len < 0)
				goto error_free_ops_free_cmd;
			acl_.user = user;
			acl_.group = group;
			acl_.permissions = encode(permissions);
			/* create or update file with ACLs read from stdin */
			if (!file_handle) {
				/*
				 * Remove the file (if it exists) so that new
				 * ACLs are created -- nasty hack!
				 */
				f_ops_delete(fs, filename, &acl_);
				file_handle = f_ops_create(fs, filename, &acl_);
				free(opsline);
				if (file_handle) {
					printf("%d\tY\tOK\n", error_line);
					goto acl_loop;
				} else {
					/*
					 * acl failed the first time but we
					 * still need to consume lines until
					 * reaching the "." line.
					 */
					/* TODO: corner case here? */
					printf("%d\tN\tE: "
					       "Failed to create file\n",
					       error_line);
					get_at_end_of_command(input_stream);
					goto cmd_loop;
				}
			} else {
				if (f_ops_update(fs, filename, &acl_))
					printf("%d\tY\tOK\n", error_line);
				else
					printf("%d\tN\tE: "
					       "Failed to create file\n",
					       error_line);
				free(opsline);
				goto acl_loop;
			}
		}
		/* end of ACL command */
error_free_ops_free_cmd:
		error_line = ncmds;
		get_at_end_of_command(input_stream);
		free(opsline);
error_free_cmd:
		/*TODO: fix this ncmds or nlines*/
		printf("%d\tX\tE: Malformed line\n", error_line);
cmd_loop:
		free(cmdline);
		free(_cmdline);
	/* end of while loop */
	}

out_free_ops_free_cmd:
	free(opsline);
out_free_cmd:
	free(cmdline);
	free(_cmdline);
out:
	return ncmds > 0 ? OK : NOT_OK;
}

/*
 * main: main entry point
 */
int main(int argc, char **argv)
{
	int rval;
	struct file *FS;

	FS = f_ops_mount(&FS);
	printf("File system with read-only root \"/home\" folder\n");
	printf("User must first create his or her home folder\n");
	printf("eg.:vatlidak.phd /home/vatlidak\n");
	rval = parse_user_definition_portion(&FS, stdin);
	if (rval)
		goto abort;
#ifdef _DEBUG
	printf("----------------\n");
	ls(FS);
#endif
	rval = parse_file_operation_portion(&FS, stdin);
	if (rval)
		goto abort;
#ifdef _DEBUG
	ls(FS);
#endif
	f_ops_unmount(&FS);
	return OK;
abort:
	fprintf(stderr, "Simulation aborted\n");
	f_ops_unmount(&FS);
	return NOT_OK;
}
submission/src/parser.c0000600003466600001360000000244312624732054014645 0ustar  vatlidakphd/*
 * Filename: src/parser.c
 *
 * Description: Implements a set of parser methods
 *
 * Note that these methods will tokenize the line buffer
 * and pointers will be pointing some part of line buffer
 *
 * Copyright (C) 2015 V. Atlidakis
 *
 * COMS W4187 Fall 2015, Columbia University
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "parser.h"


int get_user(char *line, char **user, char *delimiters)
{
	char *token;

	token = strtok(line, delimiters);
	if (token == NULL)
		return -1;

	*user = token;

	return strlen(*user);
}


int get_group(char *line, char **group, char *delimiters)
{
	char *token;

	token = strtok(line, delimiters);
	if (token == NULL)
		return -1;

	*group = token;

	return strlen(*group);
}


int get_filename(char *line, char **filename, char *delimiters)
{
	char *token;

	token = strtok(line, delimiters);
	if (token == NULL)
		return 0;

	*filename = token;

	return strlen(*filename);
}


int get_cmd(char *line, char **cmd, char *delimiters)
{
	char *token;

	token = strtok(line, delimiters);
	if (token == NULL)
		return -1;

	*cmd = token;

	return strlen(*cmd);
}


int get_perm(char *line, char **perm, char *delimiters)
{
	char *token;

	token = strtok(line, delimiters);
	if (token == NULL)
		return -1;

	*perm = token;

	return strlen(*perm);
}
submission/include/0000700003466600001360000000000012624732054014034 5ustar  vatlidakphdsubmission/include/f_ops.h0000600003466600001360000000266212624732054015323 0ustar  vatlidakphd/*
 * Filename: include/f_ops.h
 *
 * Copyright (C) 2015 V. Atlidakis
 *
 * COMS W4187 Fall 2015, Columbia University
 */
#define OK 0
#define NOT_OK -1

#ifdef _DEBUG
#define DEBUG(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
#else
#define DEBUG(fmt, ...)
#endif

#define FILENAME_LEN 256
#define COMPONENT_LEN 16

#define READ 1
#define WRITE 2
#define READ_WRITE 3
#define NO_PERMISSION 0
#define INHERIT_FROM_PARENT -1


static inline int encode(const char *permission)
{
	if (!strcmp(permission, "rw"))
		return READ_WRITE;
	if (!strcmp(permission, "r"))
		return READ;
	if (!strcmp(permission, "w"))
		return WRITE;
	if (!strcmp(permission, "-"))
		return NO_PERMISSION;
	if (!strcmp(permission, "inherit"))
		return INHERIT_FROM_PARENT;
	return NO_PERMISSION;
}


int env_is_set;

struct acl {
	int permissions;
	char *user;
	char *group;
	struct acl *next;
};

struct file {
	struct acl  *acls;
	char filename[FILENAME_LEN];
	int children;
	struct file *next;
	struct file *parent;
};

struct file *f_ops_mount(struct file **fs);
struct file *f_ops_unmount(struct file **fs);
struct file *f_ops_create(struct file **fs, char *filename, struct acl *acl);
struct file *f_ops_update(struct file **fs, char *filename, struct acl *acl);
struct file *f_ops_delete(struct file **fs, char *filename, struct acl *acl);

int f_ops_acl_check(struct file **fs, char *filename, struct acl *acl);
int f_ops_invalid_home_folder(struct file **fs, char *username);
submission/include/parser.h0000600003466600001360000000072612624732054015510 0ustar  vatlidakphd/*
 * Filename: include/parser.h
 *
 * Copyright (C) 2015 V. Atlidakis
 *
 * COMS W4187 Fall 2015, Columbia University
 */
int get_user(char *line, char **user, char *delimiters);
int get_group(char *line, char **group, char *delimiters);
int get_filename(char *line, char **filename, char *delimiters);
int get_cmd(char *line, char **cmd, char *delimiters);
int get_perm(char *line, char **perm, char *delimiters);

int tokenize(char *line, char ***args, char *delim);
submission/Makefile0000600003466600001360000000107612624732054014057 0ustar  vatlidakphdCC := gcc
CFLAGS := -Wall -Iinclude
LDFLAGS :=
ifeq ($(DEBUG),1)
CFLAGS += -D_DEBUG
endif

OBJECTS := main.o parser.o f_ops.o
EXECUTABLE := ./main
TEST := ./tests/test.txt

build: $(OBJECTS)
	$(CC) $(CFLAGS) $(LDFLAGS) -o $(EXECUTABLE) $(OBJECTS)

%.o: src/%.c
	@$(CC) $(CFLAGS) -c $^

test: clean build
	cat $(TEST) | $(EXECUTABLE) 2>/dev/null

exec: clean build
	$(EXECUTABLE) 2>/dev/null

valgrid: clean build
	/usr/bin/valgrind -v --input-fd=3 < $(TEST) $(EXECUTABLE)

checkpatch:
	scripts/checkpatch.pl --no-tree -f src/*

clean:
	rm -f $(EXECUTABLE)
	rm -f $(OBJECTS)
submission/new_res/0000700003466600001360000000000012624732054014053 5ustar  vatlidakphdsubmission/new_res/out12.txt0000600003466600001360000000043612624732054015573 0ustar  vatlidakphdFile system with read-only root "/home" folder
User must first create his or her home folder
eg.:vatlidak.phd /home/vatlidak
1	Y	OK
2	X	E: Failed to create: "/home/smb/foo"
3	Y	OK
4	Y	OK
5	Y	OK
1	Y	READ suphannee.ta /home/smb	OK
2	N	WRITE suphannee.ta /home/smb/..	E: Cannot write file
submission/new_res/out13.txt0000600003466600001360000000033412624732054015571 0ustar  vatlidakphdFile system with read-only root "/home" folder
User must first create his or her home folder
eg.:vatlidak.phd /home/vatlidak
1	Y	OK
2	X	E: Failed to create: "/home"
3	Y	OK
4	Y	OK
5	Y	OK
1	Y	READ smb.faculty /home/smb	OK
submission/new_res/out27.txt0000600003466600001360000000041012624732054015571 0ustar  vatlidakphdFile system with read-only root "/home" folder
User must first create his or her home folder
eg.:vatlidak.phd /home/vatlidak
1	Y	OK
2	Y	OK
3	X	E: Failed to create: "/home/sal./."
4	Y	OK
5	Y	OK
1	Y	READ smb.columbia /home	OK
2	Y	CREATE smb.faculty /home/smb/foo	OK
submission/README.md0000600003466600001360000000433012624732054013672 0ustar  vatlidakphdSimulate ACL evaluation.
==
Copyright (C) 2015 V. Atlidakis

COMS W4187 Fall 2015, Columbia University

## Project structure

* Makefile: Makefile
* include/parser.h: Header file for parsing methods
* include/f_ops.h: Header file for file operation methods
* src/parser.c: Implements parser methods
* src/f_ops.c: Implements file operation methods
* src/main.c: Implements main loop for parsing of simulation
* scripts/checkpatch.pl: Format checking script
* tests/test.txt: A demo test file

## Notes - Conventions
Any user appearing in the user definition portion should have a dedicated home
folder except for one case: when the user tries to create his or her home folder
for the first time.

In the operations portion the commands "[CREATE|ACL] user.group filename"
do not append an ACL "user.group rw" unlike what happens in the user
definition portion (Steve's Mail -- last night -- specifies that files created
in the user definition portion will have an ACL "user.group"). In order for
ACLs to be appended in the operations portion, there needs to be an explicit
rule in a separate line that following the "[CREATE|ACL] user.group filename"
line.

An "ACL user.group filename" command overwrites any existing ACLs of filename --
that is, it does not append new ACLs. (This convention simplifies things and
helps avoid confusion.)

In the operations portion any ACL is followed by an implicit "*.* -"  rule
since the acl_check function returns no permissions, if no matching rule is
found.

## Error
* Verbose error messages are printed in stderr. To filter them out just redirect
stderr (fd:2) to /dev/null
* Errors for user.group command are printed along with the corresponding line number
for both the user definition and the operations portion.
* Errors for command are printed along with the corresponding command number.
* Note that if an error occurs in "user.group" portion of a ACL or CREATE
  comand, the lines following the error are dropped -- but the ones preceeding
  the error are resulting to valid ACLs.

## Run
* make build
* make test (small demo using tests/test.txt)
* cat custom_test_file | make exec (test using custom file)
* make valgrid (memory leak checks)

## Debug
* make DEBUG=1
* make demo (small demo using tests/test.txt)
submission/scripts/0000700003466600001360000000000012624732054014100 5ustar  vatlidakphdsubmission/tests/0000700003466600001360000000000012624732054013553 5ustar  vatlidakphdsubmission/tests/test.txt0000600003466600001360000000210212624732054015270 0ustar  vatlidakphdvatlidak.vatlidak /home/vatlidak
vatlidak.*
kostas.phd /home/kostas
roxanaphd /home/roxana
vatlidak.*
roxana.ds
*.faculty
kostas.ds
vatlidak.phd  /home/vatlidak/temp
smb.faculty /home/smb/temp
smb.faculty /home/smb
vatlida.phd /home/vatlida
vatlid.phd
.
READ smb.faculty /home/smb/temp_/a
CREATE smb.faculty /home/smb/temp
smb.faculty rw
.
CREATE smb.faculty /home/smb/temp_
smb.faculty rw
roxana.faculty r
roxana.faculty rw
vatlidak.faculty -
.
CREATE smb.faculty /home/smb/temp_i/a
.
CREATE smb.faculty /home/smb/temp_/a
.
CREATE smb_nop.faculty /home/smb/temp_/a
.
READ smb.faculty /home/smb/temp_/a
WRITE smb.faculty /home/smb/temp_/a
ACL smb.faculty /home/smb/temp_/ta
smb.faculty rw
.
READ smb.faculty /home/smb/temp_/a
WRITE smb.faculty /home/smb/temp_/a
DELETE smb.faculty /home/smb/temp_/a
READ smb.faculty /home/smb/temp_/a
WRITE smb.nopfaculty /home/smb/
CREATE smb.nopfaculty /home/smb/lalalala
smb.faculty rw
smb.faculty r
smb* rw
smb* rw
smb* rw
smb.faculty rw
.
READ smb.faculty /home/smb/temp_/b_________
READ smbfaculty /home/smb/temp_/a
READ smb.faculty /home/smb/temp_/a