/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*	Copyright (c) 1987, 1988 Microsoft Corporation	*/

/*	  All Rights Reserved	*/

#include "lint.h"

#include "libc.h"

#include <stdio.h>

#include <stdlib.h>

#include <deflt.h>

#include <sys/types.h>

#include <string.h>

#include <ctype.h>

#include <unistd.h>

#include "tsd.h"

#define	TSTBITS(flags, mask)	(((flags) & (mask)) == (mask))

struct thr_data {

	int  Dcflags;	/* [re-]initialized on each call to defopen() */

	FILE *fp;

	char *buf;

};

static int	defopen_common(const char *, struct thr_data *);

static void strip_quotes(char *);

#define	BUFFERSIZE	1024

/*

 * destructor for per-thread data, registered with tsdalloc()

 */

static void

free_thr_data(void *arg)

{

	struct thr_data *thr_data = (struct thr_data *)arg;

	if (thr_data->fp) {

		(void) fclose(thr_data->fp);

		thr_data->fp = NULL;

	}

	if (thr_data->buf) {

		lfree(thr_data->buf, BUFFERSIZE);

		thr_data->buf = NULL;

	}

}

/*

 * get the per-thread-data-item for the calling thread

 */

static struct thr_data *

get_thr_data(void)

{

	struct thr_data *thr_data =

	    tsdalloc(_T_DEFREAD, sizeof (*thr_data), free_thr_data);

	return (thr_data);

}

/*

 *	defopen() - declare defopen filename

 *

 *	defopen(fn)

 *		char *fn

 *

 *	If 'fn' is non-null; it is a full pathname of a file

 *	which becomes the one read by subsequent defread() calls.

 *	If 'fn' is null the defopen file is closed.

 *

 *	see defread() for more details.

 *

 *	EXIT    returns 0 if ok

 *		returns -1 if error

 */

int

defopen(char *fn)

{

	struct thr_data *thr_data = get_thr_data();

	return (defopen_common(fn, thr_data));

}

/*

 *	defopen_r() - declare defopen filename (reentrant)

 *

 *	defopen_r(const char *fn)

 *

 *	'fn' is a full pathname of a file which becomes the one read

 *	by subsequent defread_r() calls.  defopen_r returns a pointer

 *	to the internally allocated buffer containing the file descriptor.

 *	The pointer should be specified to the following defread_r and

 *	defcntl_r functions.  As the pointer to be returned points to

 *	the libc lmalloc'd memory, defclose_r must be used to close

 *	the defopen file and to release the allocated memory.  Caller

 *	must not try to release the memory by free().

 *

 *	see defread_r() for more details.

 *

 *	EXIT    returns non-NULL pointer if success

 *		returns NULL if error

 */

void *

defopen_r(const char *fn)

{

	/* memory allocated by lmalloc gets initialized to zeros */

	struct thr_data	*thr_data = lmalloc(sizeof (struct thr_data));

	if (defopen_common(fn, thr_data) < 0) {

		if (thr_data != NULL)

			lfree(thr_data, sizeof (struct thr_data));

		return (NULL);

	}

	return ((void *)thr_data);

}

static int

defopen_common(const char *fn, struct thr_data *thr_data)

{

	if (thr_data == NULL)

		return (-1);

	if (thr_data->fp != NULL) {

		(void) fclose(thr_data->fp);

		thr_data->fp = NULL;

	}

	if (fn == NULL)

		return (0);

	if ((thr_data->fp = fopen(fn, "rF")) == NULL)

		return (-1);

	/*

	 * We allocate the big buffer only if the fopen() succeeds.

	 * Notice that we deallocate the buffer only when the thread exits

	 * for defopen().

	 * There are misguided applications that assume that data returned

	 * by defread() continues to exist after defopen(NULL) is called.

	 */

	if (thr_data->buf == NULL &&

	    (thr_data->buf = lmalloc(BUFFERSIZE)) == NULL) {

		(void) fclose(thr_data->fp);

		thr_data->fp = NULL;

		return (-1);

	}

	thr_data->Dcflags = DC_STD;

	return (0);

}

/*

 *	defread() - read an entry from the defopen file

 *

 *	defread(cp)

 *		char *cp

 *

 *	The defopen data file must have been previously opened by

 *	defopen().  defread scans the data file looking for a line

 *	which begins with the string '*cp'.  If such a line is found,

 *	defread returns a pointer to the first character following

 *	the matched string (*cp).  If no line is found or no file

 *	is open, defread() returns NULL.

 *

 *	Note that there is no way to simultaneously peruse multiple

 *	defopen files; since there is no way of indicating 'which one'

 *	to defread().  If you want to peruse a secondary file you must

 *	recall defopen().  If you need to go back to the first file,

 *	you must call defopen() again.

 */

char *

defread(char *cp)

{

	struct thr_data *thr_data = get_thr_data();

	return (defread_r(cp, thr_data));

}

/*

 *	defread_r() - read an entry from the defopen file

 *

 *	defread_r(const char *cp, void *defp)

 *

 *	defread_r scans the data file associated with the pointer

 *	specified by 'defp' that was returned by defopen_r(), and

 *	looks for a line which begins with the string '*cp'.

 *	If such a line is found, defread_r returns a pointer to

 *	the first character following the matched string (*cp).

 *	If no line is found or no file is open, defread_r() returns NULL.

 */

char *

defread_r(const char *cp, void *ptr)

{

	struct thr_data *thr_data = (struct thr_data *)ptr;

	int (*compare)(const char *, const char *, size_t);

	char *buf_tmp;

	char *ret_ptr = NULL;

	size_t off, patlen;

	if (thr_data == NULL || thr_data->fp == NULL)

		return (NULL);

	compare = TSTBITS(thr_data->Dcflags, DC_CASE) ? strncmp : strncasecmp;

	patlen = strlen(cp);

	if (!TSTBITS(thr_data->Dcflags, DC_NOREWIND))

		rewind(thr_data->fp);

	while (fgets(thr_data->buf, BUFFERSIZE, thr_data->fp)) {

		for (buf_tmp = thr_data->buf; *buf_tmp == ' '; buf_tmp++)

			;

		off = strlen(buf_tmp) - 1;

		if (buf_tmp[off] == '\n')

			buf_tmp[off] = 0;

		else

			break;	/* line too long */

		if ((*compare)(cp, buf_tmp, patlen) == 0) {

			/* found it */

			/* strip quotes if requested */

			if (TSTBITS(thr_data->Dcflags, DC_STRIP_QUOTES)) {

				strip_quotes(buf_tmp);

			}

			ret_ptr = &buf_tmp[patlen];

			break;

		}

	}

	return (ret_ptr);

}

/*

 *	defcntl -- default control

 *

 *	SYNOPSIS

 *	  oldflags = defcntl(cmd, arg);

 *

 *	ENTRY

 *	  cmd		Command.  One of DC_GET, DC_SET.

 *	  arg		Depends on command.  If DC_GET, ignored.

 *			If DC_SET, new flags value, created by ORing

 *			the DC_* bits.

 *	RETURN

 *	  oldflags	Old value of flags.  -1 on error.

 *	NOTES

 *	  The following commands are implemented:

 *

 *	  DC_CASE:		respect(on)/ignore(off) case

 *	  DC_NOREWIND:		don't(on)/do(off) reqind in defread

 *	  DC_STRIP_QUOTES:	strip(on)/leave(off) qoates

 */

int

defcntl(int cmd, int newflags)

{

	struct thr_data *thr_data = get_thr_data();

	return (defcntl_r(cmd, newflags, thr_data));

}

/*

 *	defcntl_r -- default control

 *

 *	SYNOPSIS

 *	  oldflags = defcntl_r(int cmd, int arg, void *defp);

 *

 *	ENTRY

 *	  cmd		Command.  One of DC_GET, DC_SET.

 *	  arg		Depends on command.  If DC_GET, ignored.

 *			If DC_SET, new flags value, created by ORing

 *			the DC_* bits.

 *	  defp		pointer to the defopen'd descriptor

 *

 *	RETURN

 *	  oldflags	Old value of flags.  -1 on error.

 *	NOTES

 *	  The following commands are implemented:

 *

 *	  DC_CASE:		respect(on)/ignore(off) case

 *	  DC_NOREWIND:		don't(on)/do(off) reqind in defread

 *	  DC_STRIP_QUOTES:	strip(on)/leave(off) qoates

 */

int

defcntl_r(int cmd, int newflags, void *ptr)

{

	struct thr_data *thr_data = (struct thr_data *)ptr;

	int  oldflags;

	if (thr_data == NULL)

		return (-1);

	switch (cmd) {

	case DC_GETFLAGS:		/* query */

		oldflags = thr_data->Dcflags;

		break;

	case DC_SETFLAGS:		/* set */

		oldflags = thr_data->Dcflags;

		thr_data->Dcflags = newflags;

		break;

	default:			/* error */

		oldflags = -1;

		break;

	}

	return (oldflags);

}

/*

 *	defclose_r() - close defopen file

 *

 *	defclose_r(void *defp)

 *

 *	defclose_r closes the defopen file associated with the specified

 *	pointer and releases the allocated resources.

 */

void

defclose_r(void *ptr)

{

	struct thr_data *thr_data = (struct thr_data *)ptr;

	(void) fclose(thr_data->fp);

	lfree(thr_data->buf, BUFFERSIZE);

	lfree(thr_data, sizeof (struct thr_data));

}

/*

 *	strip_quotes -- strip double (") or single (') quotes from a buffer

 *

 *	ENTRY

 *	  ptr		initial string

 *

 *	EXIT

 *	  ptr		string with quotes (if any) removed

 */

static void

strip_quotes(char *ptr)

{

	char *strip_ptr = NULL;

	while (*ptr != '\0') {

		if ((*ptr == '"') || (*ptr == '\'')) {

			if (strip_ptr == NULL)

				strip_ptr = ptr;	/* skip over quote */

		} else {

			if (strip_ptr != NULL) {

				*strip_ptr = *ptr;

				strip_ptr++;

			}

		}

		ptr++;

	}

	if (strip_ptr != NULL) {

		*strip_ptr = '\0';

	}

}