connectors/jk/native/isapi/inifile.c

/*
 *  Copyright 1999-2004 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/***************************************************************************
 * Description: DSAPI plugin for Lotus Domino                              *
 * Author:      Andy Armstrong <andy@tagish.com>                           *
 * Date:        20010603                                                   *
 * Version:     $Revision$                                           *
 ***************************************************************************/

#include "config.h"
#include "inifile.h"
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* We have one of these for each ini file line. Once we've read the
 * file and parsed it we'll have an array in key order containing one
 * of these for each configuration item in file.
 */
typedef struct
{
	const char *key;
	const char *value;

} inifile_key;

static char *file;			/* the text of the ini file				*/
static inifile_key *keys;	/* an array of keys, one per item		*/
static size_t klen;			/* length of the key array				*/

/* Text that will prefix all of our error messages */
#define ERRPFX "INIFILE: "
/* Various error messages that we can return */
ERRTYPE inifile_outofmemory		= ERRPFX "Out of memory";
ERRTYPE inifile_filenotfound	= ERRPFX "File not found";
ERRTYPE inifile_readerror		= ERRPFX "Error reading file";
#define SYNFMT ERRPFX "File %s, line %d: %s"

/* Case insensitive string comparison, works like strcmp() */
static int inifile__stricmp(const char *s1, const char *s2)
{
	while (*s1 && tolower(*s1) == tolower(*s2))
		s1++, s2++;
	return tolower(*s1) - tolower(*s2);
}

/* Compare keys, suitable for passing to qsort() */
static int inifile__cmp(const void *k1, const void *k2)
{
	const inifile_key *kk1 = (const inifile_key *) k1;
	const inifile_key *kk2 = (const inifile_key *) k2;
	return inifile__stricmp(kk1->key, kk2->key);
}

/* Return a new syntax error message. */
static ERRTYPE inifile__syntax(jk_pool_t *p, const char *file, int line, const char *msg)
{
	static const char synfmt[] = SYNFMT;
	size_t len = sizeof(synfmt) + strlen(msg) + strlen(file) + 10 /* fudge for line number */;
	char *buf = jk_pool_alloc(p, len);
	sprintf(buf, synfmt, file, line, msg);
	return buf;
}

/* Various macros to tidy up the parsing code */

/* Characters that are OK in the keyname */
#define KEYCHR(c) \
	(isalnum(c) || (c) == '.' || (c) == '_')

/* Skip whitespace */
#define SKIPSPC() \
	while (*fp == '\t' || *fp == ' ') fp++

/* Skip to the end of the current line */
#define SKIPLN() \
	while (*fp != '\0' && *fp != '\r' && *fp != '\n') fp++

/* Move from the end of the current line to the start of the next, learning what the
 * newline character is and counting lines
 */
#define NEXTLN() \
	do { while (*fp == '\r' || *fp == '\n') { if (nlc == -1) nlc = *fp; if (*fp == nlc) ln++; fp++; } } while (0)

/* Build the index. Called when the inifile is loaded by inifile_load()
 */
static ERRTYPE inifile__index(jk_pool_t *p, const char *name)
{
	int pass;
	int ln = 1;
	int nlc = -1;

	/* Make two passes over the data. First time we're just counting
	 * the lines that contain values so we can allocate the index, second
	 * time we build the index.
	 */
	for (pass = 0; pass < 2; pass++)
	{
		char *fp = file;
		char *ks = NULL, *ke;	/* key start, end */
		char *vs = NULL, *ve;	/* value start, end */
		klen = 0;

		while (*fp != '\0')
		{
			SKIPSPC();

			/* turn a comment into an empty line by moving to the next \r|\n */
			if (*fp == '#' || *fp == ';')
				SKIPLN();

			if (*fp != '\0' && *fp != '\r' && *fp != '\n')
			{
				ks = fp;		/* start of key */
				while (KEYCHR(*fp)) fp++;
				ke = fp;		/* end of key */
				SKIPSPC();

				if (*fp != '=')
					return inifile__syntax(p, name, ln, "Missing '=' or illegal character in key");

				fp++; /* past the = */
				SKIPSPC();
				vs = fp;
				SKIPLN();
				ve = fp;
				/* back up over any trailing space */
				while (ve > vs && (ve[-1] == ' ' || ve[-1] == '\t')) ve--;
				NEXTLN(); /* move forwards *before* we trash the eol characters */

				if (NULL != keys) /* second pass? if so stash a pointer */
				{
					*ke = '\0';
					*ve = '\0';
					keys[klen].key = ks;
					keys[klen].value = vs;
				}

				klen++;
			}
			else
			{
				NEXTLN();
			}
		}

		if (NULL == keys && (keys = jk_pool_alloc(p, sizeof(inifile_key) * klen), NULL == keys))
			return inifile_outofmemory;
	}

	/* got the index now, sort it so we can search it quickly */
	qsort(keys, klen, sizeof(inifile_key), inifile__cmp);

	return ERRNONE;
}

/* Read an INI file from disk
 */
ERRTYPE inifile_read(jk_pool_t *p, const char *name)
{
	FILE *fl;
	size_t flen;
	int ok;

	if (fl = fopen(name, "rb"), NULL == fl)
		return inifile_filenotfound;

	fseek(fl, 0L, SEEK_END);
	flen = (size_t) ftell(fl);
	fseek(fl, 0L, SEEK_SET);

	/* allocate one extra byte for trailing \0
	 */
	if (file = jk_pool_alloc(p, flen+1), NULL == file)
	{
		fclose(fl);
		return inifile_outofmemory;
	}

	ok = (fread(file, flen, 1, fl) == 1);
	fclose(fl);
	if (!ok) return inifile_readerror;

	file[flen] = '\0';	/* terminate it to simplify parsing */

	return inifile__index(p, name);
}

/* Find the value associated with the given key returning it or NULL
 * if no match is found. Key name matching is case insensitive.
 */
const char *inifile_lookup(const char *key)
{
	int lo, mid, hi, cmp;

	if (NULL == keys)
		return NULL;

	for (lo = 0, hi = klen-1; lo <= hi; )
	{
		mid = (lo + hi) / 2;
		cmp = inifile__stricmp(key, keys[mid].key);
		if (cmp < 0)	/* key in array is greater */
			hi = mid-1;
		else if (cmp > 0)
			lo = mid+1;
		else
			return keys[mid].value;
	}

	return NULL;
}

#ifdef TEST

static jk_pool_t pool;
extern void jk_dump_pool(jk_pool_t *p, FILE *f); /* not declared in header */

int main(void)
{
	ERRTYPE e;
	unsigned k;
	int rc = 0;

	jk_open_pool(&pool, NULL, 0);

	e = inifile_read(&pool, "ok.ini");
	if (e == ERRNONE)
	{
		printf("%u keys in ok.ini\n", klen);
		for (k = 0; k < klen; k++)
		{
			const char *val = inifile_lookup(keys[k].key);
			printf("Key: \"%s\", value: \"%s\"\n", keys[k].key, val);
		}
	}
	else
	{
		printf("Error reading ok.ini: %s\n", e);
		rc = 1;
	}

	e = inifile_read(&pool, "bad.ini");
	if (e == ERRNONE)
	{
		printf("%u keys in bad.ini\n", klen);
		for (k = 0; k < klen; k++)
		{
			const char *val = inifile_lookup(keys[k].key);
			printf("Key: \"%s\", value: \"%s\"\n", keys[k].key, val);
		}
		rc = 1;		/* should be a syntax error */
	}
	else
	{
		printf("Error reading bad.ini: %s (which is OK: that's what we expected)\n", e);
	}

	jk_dump_pool(&pool, stdout);
	jk_close_pool(&pool);

	return rc;
}
#endif