#include "prof_int.h"

#include <stdio.h>

#include <string.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <errno.h>

#include <ctype.h>

#define SECTION_SEP_CHAR '/'

#define STATE_INIT_COMMENT 1

#define STATE_STD_LINE 2

#define STATE_GET_OBRACE 3

struct parse_state {

int state;

int group_level;

struct profile_node *root_section;

struct profile_node *current_section;

};

static char *skip_over_blanks(char *cp)

{

while (*cp && isspace((int) (*cp)))

cp++;

return cp;

}

static void strip_line(char *line)

{

char *p = line + strlen(line);

while (p > line && (p[-1] == '\n' || p[-1] == '\r'))

*p-- = 0;

}

static void parse_quoted_string(char *str)

{

char *to, *from;

to = from = str;

for (to = from = str; *from && *from != '"'; to++, from++) {

if (*from == '\\') {

from++;

switch (*from) {

case 'n':

*to = '\n';

break;

case 't':

*to = '\t';

break;

case 'b':

*to = '\b';

break;

default:

*to = *from;

}

continue;

}

*to = *from;

}

*to = '\0';

}

static errcode_t parse_init_state(struct parse_state *state)

{

state->state = STATE_INIT_COMMENT;

state->group_level = 0;

return profile_create_node("(root)", 0, &state->root_section);

}

static errcode_t parse_std_line(char *line, struct parse_state *state)

{

char *cp, ch, *tag, *value;

char *p;

errcode_t retval;

struct profile_node *node;

int do_subsection = 0;

void *iter = 0;

if (*line == 0)

return 0;

cp = skip_over_blanks(line);

if (cp[0] == ';' || cp[0] == '#')

return 0;

strip_line(cp);

ch = *cp;

if (ch == 0)

return 0;

if (ch == '[') {

if (state->group_level > 0)

return PROF_SECTION_NOTOP;

cp++;

p = strchr(cp, ']');

if (p == NULL)

return PROF_SECTION_SYNTAX;

*p = '\0';

retval = profile_find_node_subsection(state->root_section,

cp, &iter, 0,

&state->current_section);

if (retval == PROF_NO_SECTION) {

retval = profile_add_node(state->root_section,

cp, 0,

&state->current_section);

if (retval)

return retval;

} else if (retval)

return retval;

/*

cp = p+1;

if (*cp == '*') {

profile_make_node_final(state->current_section);

cp++;

}

/*

cp = skip_over_blanks(cp);

if (*cp)

return PROF_SECTION_SYNTAX;

return 0;

}

if (ch == '}') {

if (state->group_level == 0)

return PROF_EXTRA_CBRACE;

if (*(cp+1) == '*')

profile_make_node_final(state->current_section);

retval = profile_get_node_parent(state->current_section,

&state->current_section);

if (retval)

return retval;

state->group_level--;

return 0;

}

/*

tag = cp;

cp = strchr(cp, '=');

if (!cp)

return PROF_RELATION_SYNTAX;

if (cp == tag)

return PROF_RELATION_SYNTAX;

*cp = '\0';

p = tag;

/* Look for whitespace on left-hand side. */

while (p < cp && !isspace((int)*p))

p++;

if (p < cp) {

/* Found some sort of whitespace. */

*p++ = 0;

/* If we have more non-whitespace, it's an error. */

while (p < cp) {

if (!isspace((int)*p))

return PROF_RELATION_SYNTAX;

p++;

}

}

cp = skip_over_blanks(cp+1);

value = cp;

if (value[0] == '"') {

value++;

parse_quoted_string(value);

} else if (value[0] == 0) {

do_subsection++;

state->state = STATE_GET_OBRACE;

} else if (value[0] == '{' && *(skip_over_blanks(value+1)) == 0)

do_subsection++;

else {

cp = value + strlen(value) - 1;

while ((cp > value) && isspace((int) (*cp)))

*cp-- = 0;

}

if (do_subsection) {

p = strchr(tag, '*');

if (p)

*p = '\0';

retval = profile_add_node(state->current_section,

tag, 0, &state->current_section);

if (retval)

return retval;

if (p)

profile_make_node_final(state->current_section);

state->group_level++;

return 0;

}

p = strchr(tag, '*');

if (p)

*p = '\0';

profile_add_node(state->current_section, tag, value, &node);

if (p)

profile_make_node_final(node);

return 0;

}

static errcode_t parse_line(char *line, struct parse_state *state)

{

char *cp;

switch (state->state) {

case STATE_INIT_COMMENT:

if (line[0] != '[')

return 0;

state->state = STATE_STD_LINE;

case STATE_STD_LINE:

return parse_std_line(line, state);

case STATE_GET_OBRACE:

cp = skip_over_blanks(line);

if (*cp != '{')

return PROF_MISSING_OBRACE;

state->state = STATE_STD_LINE;

}

return 0;

}

errcode_t profile_parse_file(FILE *f, struct profile_node **root)

{

#define BUF_SIZE 2048

char *bptr;

errcode_t retval;

struct parse_state state;

bptr = malloc (BUF_SIZE);

if (!bptr)

return ENOMEM;

retval = parse_init_state(&state);

if (retval) {

free (bptr);

return retval;

}

while (!feof(f)) {

if (fgets(bptr, BUF_SIZE, f) == NULL)

break;

#ifndef PROFILE_SUPPORTS_FOREIGN_NEWLINES

retval = parse_line(bptr, &state);

if (retval) {

/* Solaris Kerberos: check if an unconfigured file */

if (strstr(bptr, "___"))

retval = PROF_NO_PROFILE;

profile_free_node(state.root_section);

free (bptr);

return retval;

}

#else

{

char *p, *end;

if (strlen(bptr) >= BUF_SIZE - 1) {

/* The string may have foreign newlines and

long offset;

char *c = bptr + strlen (bptr);

for (offset = 0; offset > -BUF_SIZE; offset--) {

if (*c == '\r' || *c == '\n') {

*c = '\0';

fseek (f, offset, SEEK_CUR);

break;

}

c--;

}

}

/* First change all newlines to \n */

for (p = bptr; *p != '\0'; p++) {

if (*p == '\r')

*p = '\n';

}

/* Then parse all lines */

p = bptr;

end = bptr + strlen (bptr);

while (p < end) {

char* newline;

char* newp;

newline = strchr (p, '\n');

if (newline != NULL)

*newline = '\0';

/* parse_line modifies contents of p */

newp = p + strlen (p) + 1;

retval = parse_line (p, &state);

if (retval) {

profile_free_node(state.root_section);

free (bptr);

return retval;

}

p = newp;

}

}

#endif

}

*root = state.root_section;

free (bptr);

return 0;

}

static int need_double_quotes(char *str)

{

if (!str)

return 0;

if (str[0] == '\0')

return 1;

if (isspace((int) (*str)) ||isspace((int) (*(str + strlen(str) - 1))))

return 1;

if (strchr(str, '\n') || strchr(str, '\t') || strchr(str, '\b'))

return 1;

return 0;

}

static void output_quoted_string(char *str, void (*cb)(const char *,void *),

void *data)

{

char ch;

char buf[2];

cb("\"", data);

if (!str) {

cb("\"", data);

return;

}

buf[1] = 0;

while ((ch = *str++)) {

switch (ch) {

case '\\':

cb("\\\\", data);

break;

case '\n':

cb("\\n", data);

break;

case '\t':

cb("\\t", data);

break;

case '\b':

cb("\\b", data);

break;

default:

/* This would be a lot faster if we scanned

buf[0] = ch;

cb(buf, data);

break;

}

}

cb("\"", data);

}

#if defined(_WIN32)

#define EOL "\r\n"

#endif

#ifndef EOL

#define EOL "\n"

#endif

static void dump_profile(struct profile_node *root, int level,

void (*cb)(const char *, void *), void *data)

{

int i;

struct profile_node *p;

void *iter;

long retval;

char *name, *value;

iter = 0;

do {

retval = profile_find_node_relation(root, 0, &iter,

&name, &value);

if (retval)

break;

for (i=0; i < level; i++)

cb("\t", data);

if (need_double_quotes(value)) {

cb(name, data);

cb(" = ", data);

output_quoted_string(value, cb, data);

cb(EOL, data);

} else {

cb(name, data);

cb(" = ", data);

cb(value, data);

cb(EOL, data);

}

} while (iter != 0);

iter = 0;

do {

retval = profile_find_node_subsection(root, 0, &iter,

&name, &p);

if (retval)

break;

if (level == 0) { /* [xxx] */

cb("[", data);

cb(name, data);

cb("]", data);

cb(profile_is_node_final(p) ? "*" : "", data);

cb(EOL, data);

dump_profile(p, level+1, cb, data);

cb(EOL, data);

} else { /* xxx = { ... } */

for (i=0; i < level; i++)

cb("\t", data);

cb(name, data);

cb(" = {", data);

cb(EOL, data);

dump_profile(p, level+1, cb, data);

for (i=0; i < level; i++)

cb("\t", data);

cb("}", data);

cb(profile_is_node_final(p) ? "*" : "", data);

cb(EOL, data);

}

} while (iter != 0);

}

static void dump_profile_to_file_cb(const char *str, void *data)

{

fputs(str, data);

}

errcode_t profile_write_tree_file(struct profile_node *root, FILE *dstfile)

{

dump_profile(root, 0, dump_profile_to_file_cb, dstfile);

return 0;

}

struct prof_buf {

char *base;

size_t cur, max;

int err;

};

static void add_data_to_buffer(struct prof_buf *b, const void *d, size_t len)

{

if (b->err)

return;

if (b->max - b->cur < len) {

size_t newsize;

char *newptr;

newsize = b->max + (b->max >> 1) + len + 1024;

newptr = realloc(b->base, newsize);

if (newptr == NULL) {

b->err = 1;

return;

}

b->base = newptr;

b->max = newsize;

}

memcpy(b->base + b->cur, d, len);

b->cur += len; /* ignore overflow */

}

static void dump_profile_to_buffer_cb(const char *str, void *data)

{

add_data_to_buffer((struct prof_buf *)data, str, strlen(str));

}

errcode_t profile_write_tree_to_buffer(struct profile_node *root,

char **buf)

{

struct prof_buf prof_buf = { 0, 0, 0, 0 };

dump_profile(root, 0, dump_profile_to_buffer_cb, &prof_buf);

if (prof_buf.err) {

*buf = NULL;

return ENOMEM;

}

add_data_to_buffer(&prof_buf, "", 1); /* append nul */

if (prof_buf.max - prof_buf.cur > (prof_buf.max >> 3)) {

char *newptr = realloc(prof_buf.base, prof_buf.cur);

if (newptr)

prof_buf.base = newptr;

}

*buf = prof_buf.base;

return 0;

}