libutil

// util/mode.c, version 1.0.3
// Mode source file from libutil
// Copyright (C) 2020, Jakob Wakeling
// MIT Licence

/*
	TODO Handle copying permissions
*/

#include "mode.h"

#include <sys/types.h>

#include <stdio.h>
#include <stdlib.h>

static inline int getop(char **s);
static inline mode_t getref(char **s);

/* Parse an octal or symbolic mode string */
chmod_t *strmode(char *str) {
	char *s = str; chmod_t *m; mode_t mode = 0; size_t i;
	
	// Try and parse an octal mode
	for (register mode_t d; *s >= '0' && *s <= '7'; ++s) {
		d = *s - '0'; if (mode > (07777 - d) / 8) { break; }
		mode = mode * 8 + d;
	}
	
	if (!*s) {
		m = (chmod_t *)malloc(2 * sizeof (*m));
		
		// Construct a chmod_t from the octal mode and return it
		m[0].flag = MF_NORM; m[1].flag = MF_NULL;
		m[0].op = '='; m[0].ref = M_ALL; m[0].mod = mode;
		
		return m;
	}
	
	// If the octal mode is invalid return NULL
	else if (s != str) { return NULL; }
	
	// Allocate necesary memory for chmod_t array
	for (i = 1; *s; ++s) { i += (*s == '+' || *s == '-' || *s == '='); }
	m = (chmod_t *)malloc((i + 1) * sizeof (*m)); s = str; m[i].flag = MF_NULL;
	
	i = 0; do { // Parse each part of the symbolic mode string
		for (mode_t ref = getref(&s); ((m[i].op = getop(&s))); ++i) {
			m[i].flag = MF_NORM; m[i].ref = ref;
			
			// Process the next mode
			for (m[i].mod = 0;;) switch (*s) {
				case 'r': { m[i].mod |= M_RD; ++s; continue; }
				case 'w': { m[i].mod |= M_WR; ++s; continue; }
				case 'x': { m[i].mod |= M_EX; ++s; continue; }
				case 'X': { m[i].flag = MF_XIFX; ++s; continue; }
				case 's': { m[i].mod |= M_ID; ++s; continue; }
				case 't': { m[i].mod |= M_ST; ++s; continue; }
				default: { goto end; }
			} end:;
		}
	} while (*s++ == ',' && *s);
	
	// If the symbolic mode is invalid return NULL
	if (*--s) { free(m); return NULL; } return m;
}

/* Process and return next operator */
static inline int getop(char **s) {
	switch (**s) { case '+': case '-': case '=': { return *(*s)++; }}
	return 0;
}

/* Process and return next reference */
static inline mode_t getref(char **s) {
	for (mode_t ref = 0;;) switch (**s) {
	case 'u': { ref |= M_USR; ++*s; continue; }
	case 'g': { ref |= M_GRP; ++*s; continue; }
	case 'o': { ref |= M_OTH; ++*s; continue; }
	case 'a': { ref |= M_ALL; ++*s; continue; }
	default: { return ref; }
	}
}