#include "context_internal.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define COMP_USER  0
#define COMP_ROLE  1
#define COMP_TYPE  2
#define COMP_RANGE 3

typedef struct {
        char *current_str; /* This is made up-to-date only when needed */
        char *(component[4]); 
} context_private_t;

/*
 * Allocate a new context, initialized from str.  There must be 3 or
 * 4 colon-separated components and no whitespace in any component other
 * than the MLS component.
 */
context_t
context_new(const char *str)
{
        int i,count;
        context_private_t *n = (context_private_t*) malloc(sizeof(context_private_t));
        context_t result = (context_t) malloc(sizeof(context_s_t));
        const char *p,*tok;
        
	if (result)
		result->ptr = n;
	else
		free(n);
        if ( n == 0 || result == 0 ) { goto err; }
        n->current_str = n->component[0] = n->component[1] = n->component[2] =
                n->component[3] = 0;
        for ( i = count = 0, p = str; *p; p++ ) {
                switch ( *p ) { 
                case ':': count++; break;
                case '\n': case '\t': case '\r': goto err; /* sanity check */
                case ' ': if (count < 3) goto err; /* sanity check */
                }
        }
	/*
	 * Could be anywhere from 2 - 5
	 * e.g user:role:type to user:role:type:sens1:cata-sens2:catb
	 */
        if ( count < 2 || count > 5 ) { /* might not have a range */
                goto err;
        }

        n->component[3] = 0;
        for ( i = 0, tok = str; *tok; i++ ) {
		if (i<3)
                	for ( p = tok; *p && *p != ':'; p++ ) { /* empty */ }
		else
		{
			/* MLS range is one component */
                	for ( p = tok; *p; p++ ) { /* empty */ }
		}
                n->component[i] = (char*) malloc(p-tok+1);
		if (n->component[i] == 0)
		  goto err;
                strncpy(n->component[i],tok,p-tok);
                n->component[i][p-tok] = '\0';
                tok = *p ? p+1 : p;
        }
        return result;
 err:
        context_free(result);
        return 0;
}
hidden_def(context_new)

static void 
conditional_free(char** v)
{
        if ( *v ) { 
                free(*v); 
        }
        *v = 0;
}

/*
 * free all storage used by a context.  Safe to call with
 * null pointer. 
 */
void 
context_free(context_t context)
{
        context_private_t *n;
        int i;
        if ( context ) {
                n = context->ptr;
                if ( n ) {
                        conditional_free(&n->current_str);
                        for ( i = 0; i < 4; i++ ) {
                                conditional_free(&n->component[i]);
                        }
                        free(n);
                }
                free(context);
        }
}
hidden_def(context_free)

/*
 * Return a pointer to the string value of the context.
 */

char *
context_str(context_t context)
{
        context_private_t *n = context->ptr;
        int i;
        size_t total = 0;
        conditional_free(&n->current_str);
        for ( i = 0; i < 4; i++ ) {
                if ( n->component[i] ) {
                        total += strlen(n->component[i])+1;
                }
        }
        n->current_str = malloc(total);
        if ( n->current_str != 0 ) {
                char *cp = n->current_str;

		cp = stpcpy(cp, n->component[0]);
		for (i = 1; i < 4; i++) {
			if (n->component[i]) {
				*cp++ = ':';
				cp = stpcpy(cp, n->component[i]);
			}
		}
        }
        return n->current_str;
}
hidden_def(context_str)

/* Returns nonzero iff failed */

static int set_comp(context_private_t* n,int index, const char *str)
{
	char *t = NULL;
        const char *p;
	if (str) {
		t = (char*) malloc(strlen(str)+1);
		if ( !t ) { return 1; }
		for ( p = str; *p; p++ ) {
			if ( *p == '\t' || *p == '\n' || *p == '\r' ||
			     ((*p == ':' || *p == ' ') && index != COMP_RANGE) ) {
				free(t);
				return 1;
			}
		}
		strcpy(t,str);
	}
        conditional_free(&n->component[index]);
        n->component[index] = t;
        return 0;
}

#define def_get(name,tag) \
const char * context_ ## name ## _get(context_t context) \
{ \
        context_private_t *n = context->ptr; \
        return n->component[tag]; \
} \
hidden_def(context_ ## name ## _get)

def_get(type,COMP_TYPE)
def_get(user,COMP_USER)
def_get(range,COMP_RANGE)
def_get(role,COMP_ROLE)

#define def_set(name,tag) \
int context_ ## name ## _set(context_t context, const char* str) \
{ \
        return set_comp(context->ptr,tag,str);\
} \
hidden_def(context_ ## name ## _set)

def_set(type,COMP_TYPE)
def_set(role,COMP_ROLE)
def_set(user,COMP_USER)
def_set(range,COMP_RANGE)