/*

 * Copyright (c) 1993, 1996, Oracle and/or its affiliates. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <ctype.h>

#include <unistd.h>

#include <string.h>

#include <errno.h>

#include "Sunowconfig.h"

/***************************************************************************

Implementation Note:  This implementation was done with some generality

	in mind.  If at some point it becomes necessary to add more

	elaborate per class or per instance data, this should be

	readily accommodated by this implementation.  

		It is assumed that the configuration database is relatively 

	small, say, fewer than 1000 entries.  There's no hard limit, but 

	there's no optimization either.

		The "package" mechanism is hokey.  It was done to

	address the concern that nobody wanted package names specified

	on a per instance basis, but there needed to be some mechanism

	that identified an instance as belonging to a package.

		The previous implementation mentioned that it was not

	MTsafe or MThot.  The same applies to this implementation.

		Error handling is very primitive.  If a more sophisticated

	means of reporting and acting upon error conditions can be

	developed..., great.

		It would be nice if we could use alloca, but since this

	is also an Xsun server library, we can't.

***************************************************************************/

/***************************************************************************

	OWconfig implementation private data structures...

***************************************************************************/

struct databaseStruct {

	int dummy;

};

struct classStruct {

	int dummy;

};

struct instanceStruct {

	char *pkg;

	int lineNumber;

	struct nodeStruct *nextInstance, *prevInstance;

};

struct attrStruct {

	char *value;

};

/*

 *  A class list is a child of the database.

 *  An instance list is a child of a class.

 *  An attribute list is a child of an instance.

 */

struct nodeStruct {

	char *name;

	unsigned int hashValue;

	struct nodeStruct *next;

	struct nodeStruct *prev;

	struct nodeStruct *parent;

	struct nodeStruct *head;	/* One end of the child list... */

	struct nodeStruct *tail;	/* The other end... */

	void (*nodeFree)();

	union {

		struct databaseStruct database;

		struct classStruct class;

		struct instanceStruct instance;

		struct attrStruct attr;

	} nodeValue;

};

/*

 *  Store comments as a singly linked list...

 */

struct commentStruct {

	char *comment;

	int lineNumber;

	struct commentStruct *next;

};

/*** Max pathname length... ***/

#define FNLENGTH 300

/*** Unit of allocation for input line buffer... ***/

#define LINEALLOCUNIT 128

/*** Max length of statically allocated strings... ***/

#define MAXVALLENGTH 128

/***************************************************************************

Data Declarations...

***************************************************************************/

static struct nodeStruct OWconfigDatabase;

static int databaseValid = 0;

static char currentPackage[MAXVALLENGTH];

static char *defaultNewPkgName="RESERVED-unassigned";

static char *defaultOldPkgName="RESERVED-oldstyle";

/*** If ever there are multiple databases, this could be moved into

     a database nodeStruct.

***/

static char *readFile1 = NULL;

static char *readFile2 = NULL;

static int OWconfigFlags = 0;

static void *(*allocMem)();

static void (*freeMem)();

static time_t readFile1TimeStamp;

static time_t readFile2TimeStamp;

static struct commentStruct *commentList = NULL;

static struct commentStruct *lastComment = NULL;

static struct nodeStruct *instanceListHead = NULL;

static struct nodeStruct *instanceListTail = NULL;

static int lineNumber;

static int lastLineNumber;

/***************************************************************************

****************************************************************************

Implementation private functions...

****************************************************************************

***************************************************************************/

#define FREENODE(np) \

	if (np->parent->head == np)\

		np->parent->head = np->next;\

	if (np->parent->tail == np)\

		np->parent->tail = np->prev;\

	if (np->next)\

		np->next->prev = np->prev;\

	if (np->prev)\

		np->prev->next = np->next;\

	freeMem(np->name);\

	freeMem((char *)np);

/***************************************************************************

freeNodeList:  The generic node list destructor...

***************************************************************************/

static void

freeNodeList(struct nodeStruct *np)

{

	struct nodeStruct *next;

	while (np) {

		if (np->head)

			freeNodeList(np->head);

		next = np->next;

		if (np->nodeFree)

			np->nodeFree(np);

		np = next;

	}

}

/***************************************************************************

freeClass:  The class node destructor...

***************************************************************************/

static void

freeClass(struct nodeStruct *cp)

{

	if (cp->head)

		freeNodeList(cp->head);

	FREENODE(cp);

	return;

}

/***************************************************************************

freeInstance:  The instance node destructor...

***************************************************************************/

static void

freeInstance(struct nodeStruct *ip)

{

	char *tmp;

	struct nodeStruct *nextInstance, *prevInstance;

	if (ip->head)

		freeNodeList(ip->head);

	tmp = ip->nodeValue.instance.pkg;

	if (tmp)

		freeMem(tmp);

	if (OWconfigFlags & OWFLAG_RETAIN) {

		nextInstance = ip->nodeValue.instance.nextInstance;

		prevInstance = ip->nodeValue.instance.prevInstance;

		if (nextInstance)

			nextInstance->nodeValue.instance.prevInstance = 

				prevInstance;

		if (prevInstance)

			prevInstance->nodeValue.instance.nextInstance = 

				nextInstance;

		if (instanceListHead == ip)

			instanceListHead = nextInstance;

		if (instanceListTail == ip)

			instanceListTail = prevInstance;

	}

	FREENODE(ip);

	return;

}

/***************************************************************************

freeAttr:  The attribute node destructor...

***************************************************************************/

static void

freeAttr(struct nodeStruct *ap)

{

	char *value;

	value = ap->nodeValue.attr.value;

	if (value)

		freeMem(value);

	FREENODE(ap);

	return;

}

/***************************************************************************

hashValue:  Generates the arithmetic sum of the bytes of the string 

	specified by "str".

***************************************************************************/

static unsigned int

hashValue(char *str)

{

        unsigned int ret = 0;

	while (*str) {

                ret += (unsigned int)*str;

		str++;

	}

        return(ret);

}

/***************************************************************************

dupString:  Given a non-null pointer to a string, allocates memory

	sufficient to contain a copy of the string pointed to by

	"str", copies the string to the newly allocated memory, and

	returns a pointer to the new string.

***************************************************************************/

static char *

dupString(char *str)

{

	int len;

	char *ptr;

	if (str) {

		len = strlen(str) + 1;

		ptr = (char *)allocMem(len);

		if (ptr)

			(void)memcpy(ptr, str, len);

		return(ptr);

	} else

		return(NULL);

}

/***************************************************************************

searchNodeList:  Searches next-wise along a list, starting at the node

	pointed to by "node", until either the end of the list is

	found, or a node whose name matches the string pointed to by

	"name".

***************************************************************************/

static struct nodeStruct *

searchNodeList(struct nodeStruct *node, char *name)

{

	unsigned int nameHash;

	nameHash = hashValue(name);

	while (node) {

		if ((nameHash == node->hashValue) && !strcmp(name, node->name))

			break;

		node = node->next;

	}

	return(node);

}

/***************************************************************************

searchClass:  Searches for the class node whose name matches the string

	pointed to by "class".

***************************************************************************/

static struct nodeStruct *

searchClass(char *class)

{

	if (OWconfigDatabase.head)

		return(searchNodeList(OWconfigDatabase.head, class));

	return((struct nodeStruct *)NULL);

}

/***************************************************************************

searchInstance:  Searches for the instance node identified by "name",

	parented by the class node identified by "class".

***************************************************************************/

static struct nodeStruct *

searchInstance(char *class, char *name)

{

	struct nodeStruct *cp;

	cp = searchClass(class);

	if (cp && cp->head) 

		return(searchNodeList(cp->head, name));

	return((struct nodeStruct *)NULL);

}

/***************************************************************************

searchAttr:  Searches for the attribute node identified by "attr",

	parented by the instance node identified by "name",

	which in turn is parented by the class node identified by "class".

***************************************************************************/

static struct nodeStruct *

searchAttr(char *class, char *name, char *attr)

{

	struct nodeStruct *instanceNode;

	instanceNode = searchInstance(class, name);

	if (instanceNode && instanceNode->head) 

		return(searchNodeList(instanceNode->head, attr));

	return((struct nodeStruct *)NULL);

}

/***************************************************************************

createClass:  Creates a new class node within the OWconfig database.

***************************************************************************/

static struct nodeStruct *

createClass(char *class)

{

	struct nodeStruct *cp;

	cp = (struct nodeStruct *)allocMem(sizeof(struct nodeStruct));

	if (!cp)

		return(NULL);

	cp->name = dupString(class);

	if (!cp->name) {

		freeMem(cp);

		return(NULL);

	}

	cp->hashValue = hashValue(class);

	cp->parent = &OWconfigDatabase;

	cp->head = NULL;

	cp->tail = NULL;

	cp->nodeFree = freeClass;

	if (!OWconfigDatabase.head) {

		OWconfigDatabase.head = cp;

	}

	cp->prev = OWconfigDatabase.tail;

	cp->next = NULL;

	if (OWconfigDatabase.tail)

		OWconfigDatabase.tail->next = cp;

	OWconfigDatabase.tail = cp;

	return(cp);

}

/***************************************************************************

createInstance:  Creates a new instance node parented by the class node

	identified by "class".  The instance node will be identified

	by "name".  If the class node does not already exist, it will

	be created.

***************************************************************************/

static struct nodeStruct *

createInstance(char *class, char *name)

{

	struct nodeStruct *cp, *ip;

	cp = searchClass(class);

	if (!cp) {

		cp = createClass(class);

		if (!cp) {

			return(NULL);

		}

	}

	ip = (struct nodeStruct *)allocMem(sizeof(struct nodeStruct));

	if (!ip)

		return(NULL);

	ip->name = dupString(name);

	if (!ip->name) {

		freeMem(ip);

		return(NULL);

	}

	ip->hashValue = hashValue(name);

	ip->parent = cp;

	ip->head = NULL;

	ip->tail = NULL;

	ip->nodeFree = freeInstance;

	ip->nodeValue.instance.pkg = NULL;

	if (OWconfigFlags & OWFLAG_RETAIN) {

		if (instanceListTail) {

			if (instanceListTail->nodeValue.instance.lineNumber ==

			    lineNumber)

				lineNumber++;

			ip->nodeValue.instance.lineNumber = lineNumber;

			ip->nodeValue.instance.nextInstance = NULL;

			ip->nodeValue.instance.prevInstance = instanceListTail;

			instanceListTail->nodeValue.instance.nextInstance = ip;

			instanceListTail = ip;

		} else {

			instanceListHead = instanceListTail = ip;

			ip->nodeValue.instance.lineNumber = lineNumber;

			ip->nodeValue.instance.nextInstance = NULL;

			ip->nodeValue.instance.prevInstance = NULL;;

		}

	}

	if (!cp->head) {

		cp->head = ip;

	}

	ip->prev = cp->tail;

	ip->next = NULL;

	if (cp->tail)

		cp->tail->next = ip;

	cp->tail = ip;

	return(ip);

}

/***************************************************************************

unlockOWconfig:  Remove the read or write lock from an OWconfig file.

***************************************************************************/

static void

unlockOWconfig(int f)

{