/*****************************************************************************
*
* Nagios-plugins parse_ini library
*
* License: GPL
* Copyright (c) 2007-2014 Nagios Plugins Development Team
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*
*
*****************************************************************************/

#include "common.h"
#include "utils_base.h"
#include "parse_ini.h"
#include "../gl/idpriv.h"
#include <ctype.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

/* np_ini_info contains the result of parsing a "locator" in the format
 * [stanza_name][@config_filename] (check_foo@/etc/foo.ini, for example)
 */
typedef struct {
	char *file;
	char *stanza;
} np_ini_info;

static char *default_ini_file_names[] = {
	"plugins.ini",
	"nagios-plugins.ini",
	NULL
};

static char *default_ini_path_names[] = {
	"/usr/local/nagios/etc/plugins.ini",
	"/usr/local/nagios/etc/nagios-plugins.ini",
	"/usr/local/etc/nagios/plugins.ini",
	"/usr/local/etc/nagios/nagios-plugins.ini",
	"/usr/local/etc/nagios-plugins.ini",
	"/usr/local/etc/nagios-plugins/nagios-plugins.ini",
	"/usr/local/etc/nagios-plugins/plugins.ini",
	"/usr/local/etc/nagios/plugins.ini",
	"/usr/local/etc/nagios/nagios-plugins.ini",
	"/etc/nagios-plugins.ini",
	"/etc/nagios/plugins.ini",
	"/etc/nagios/nagios-plugins.ini",
	"/etc/nagios-plugins/nagios-plugins.ini",
	"/etc/nagios-plugins/plugins.ini",
	"/etc/opt/nagios-plugins.ini",
	"/etc/opt/nagios/plugins.ini",
	"/etc/opt/nagios/nagios-plugins.ini",
	NULL
};

/* eat all characters from a FILE pointer until n is encountered */
#define GOBBLE_TO(f, c, n) do { (c)=fgetc((f)); } while((c)!=EOF && (c)!=(n))

/* internal function that returns the constructed defaults options */
static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts);
/* internal function that converts a single line into options format */
static int add_option(FILE *f, np_arg_list **optlst);
/* internal functions to find default file */
static char* default_file(void);
static char* default_file_in_path(void);

/* parse_locator decomposes a string of the form
 * 	[stanza][@filename]
 * into its separate parts
 */
static void parse_locator(const char *locator, const char *def_stanza, np_ini_info *i){
	size_t locator_len=0, stanza_len=0;
	char *dflt = NULL;

	/* if locator is NULL we'll use default values */
	if(locator){
		locator_len=strlen(locator);
		stanza_len=strcspn(locator, "@");
	}
	/* if a non-default stanza is provided */
	if(stanza_len>0){
		i->stanza=malloc(sizeof(char)*(stanza_len+1));
		strncpy(i->stanza, locator, stanza_len);
		i->stanza[stanza_len]='\0';
	} else { /* otherwise we use the default stanza */
		i->stanza=strdup(def_stanza);
	}
	if(i->stanza==NULL){
		die(STATE_UNKNOWN, "%s\n", _("malloc() failed!"));
	}
	/* if there is no @file part */
	if(stanza_len==locator_len){
		dflt=default_file();
		if (dflt)
			i->file=strdup(dflt);
	} else {
		i->file=strdup(&(locator[stanza_len+1]));
	}
	if(i->file==NULL || i->file[0]=='\0'){
		die(STATE_UNKNOWN, "%s\n", _("Cannot find config file in any standard location."));
	}
}

/* this is the externally visible function used by extra_opts */
np_arg_list* np_get_defaults(const char *locator, const char *default_section){
	FILE *inifile=NULL;
	np_arg_list *defaults=NULL;
	np_ini_info i;
	struct stat fstat;
	bool is_suid_set = np_suid();

	if (is_suid_set && idpriv_temp_drop() == -1) 
		die(STATE_UNKNOWN, "%s %s\n", _("Can't drop user permissions."), strerror(errno));

	parse_locator(locator, default_section, &i);
	/* If a file was specified or if we're using the default file. */
	if (i.file != NULL && strlen(i.file) > 0) {
		if (strcmp(i.file, "-") == 0) {
			inifile = stdin;
		} else {
			/* We must be able to stat() the thing. */
			if (lstat(i.file, &fstat) != 0)
				die(STATE_UNKNOWN, "%s %s\n", _("Can't read config file."), strerror(errno));
			/* The requested file must be a regular file. */
			if (!S_ISREG(fstat.st_mode))
				die(STATE_UNKNOWN, "%s\n", _("Can't read config file. Requested path is not a regular file."));
			/* We must be able to read the requested file. */
			if (access(i.file, R_OK|F_OK) != 0)
				die(STATE_UNKNOWN, "%s %s\n", _("Can't read config file."), strerror(errno));
			/* We need to successfully open the file for reading... */
			if ((inifile=fopen(i.file, "r")) == NULL)
				die(STATE_UNKNOWN, "%s %s\n", _("Can't read config file."), strerror(errno));
		}

		/* before attempting access, let's make sure inifile is not null, this should never be the case though */
		if (inifile == NULL)
			die(STATE_UNKNOWN, "%s %s\n", _("Can't read config file:"), strerror(errno));
		/* inifile points to an open FILE our ruid/rgid can access, parse its contents. */
		if (read_defaults(inifile, i.stanza, &defaults) == FALSE)
			die(STATE_UNKNOWN,"%s%s%s%s'\n", _("Invalid section '"), i.stanza, _("' in config file '"), i.file);
		if (inifile != stdin) fclose(inifile);
	}

	if (i.file != NULL) {
		free(i.file);
		i.file = NULL;
	}
	if (i.stanza != NULL) {
		free(i.stanza);
		i.stanza = NULL;
	}

	if (is_suid_set && idpriv_temp_restore() == -1) 
		die(STATE_UNKNOWN, "%s %s\n", _("Can't restore user permissions."), strerror(errno));

	return defaults;
}

/* read_defaults is where the meat of the parsing takes place.
 *
 * note that this may be called by a setuid binary, so we need to
 * be extra careful about user-supplied input (i.e. avoiding possible
 * format string vulnerabilities, etc)
 */
static int read_defaults(FILE *f, const char *stanza, np_arg_list **opts){
	int c, status=FALSE;
	size_t i, stanza_len;
	enum { NOSTANZA, WRONGSTANZA, RIGHTSTANZA } stanzastate=NOSTANZA;

	stanza_len=strlen(stanza);

	/* our little stanza-parsing state machine.  */
	while((c=fgetc(f))!=EOF){
		/* gobble up leading whitespace */
		if(isspace(c)) continue;
		switch(c){
			/* globble up comment lines */
			case ';':
			case '#':
				GOBBLE_TO(f, c, '\n');
				break;
			/* start of a stanza.  check to see if it matches */
			case '[':
				stanzastate=WRONGSTANZA;
				for(i=0; i<stanza_len; i++){
					c=fgetc(f);
					/* Strip leading whitespace */
					if(i==0) for(; isspace(c); c=fgetc(f));
					/* nope, read to the end of the line */
					if(c!=stanza[i]) {
						GOBBLE_TO(f, c, '\n');
						break;
					}
				}
				/* if it matched up to here and the next char is ']'... */
				if(i==stanza_len){
					c=fgetc(f);
					/* Strip trailing whitespace */
					for(; isspace(c); c=fgetc(f));
					if(c==']') stanzastate=RIGHTSTANZA;
				}
				break;
			/* otherwise, we're in the body of a stanza or a parse error */
			default:
				switch(stanzastate){
					/* we never found the start of the first stanza, so
					 * we're dealing with a config error
					 */
					case NOSTANZA:
						die(STATE_UNKNOWN, "%s\n", _("Config file error"));
					/* we're in a stanza, but for a different plugin */
					case WRONGSTANZA:
						GOBBLE_TO(f, c, '\n');
						break;
					/* okay, this is where we start taking the config */
					case RIGHTSTANZA:
						ungetc(c, f);
						if(add_option(f, opts)){
							die(STATE_UNKNOWN, "%s\n", _("Config file error"));
						}
						status=TRUE;
						break;
				}
				break;
		}
	}
	return status;
}

/*
 * read one line of input in the format
 * 	^option[[:space:]]*(=[[:space:]]*value)?
 * and creates it as a cmdline argument
 * 	--option[=value]
 * appending it to the linked list optbuf.
 */
static int add_option(FILE *f, np_arg_list **optlst){
	np_arg_list *opttmp=*optlst, *optnew;
	char *linebuf=NULL, *lineend=NULL, *optptr=NULL, *optend=NULL;
	char *eqptr=NULL, *valptr=NULL, *valend=NULL;
	short done_reading=0, equals=0, value=0;
	size_t cfg_len=0, read_sz=8, linebuf_sz=0, read_pos=0;
	size_t opt_len=0, val_len=0;

	/* read one line from the file */
	while(!done_reading){
		/* grow if necessary */
		if(linebuf==NULL || read_pos+read_sz >= linebuf_sz){
			linebuf_sz=(linebuf_sz>0)?linebuf_sz<<1:read_sz;
			linebuf=realloc(linebuf, linebuf_sz);
			if(linebuf==NULL) die(STATE_UNKNOWN, "%s\n", _("malloc() failed!"));
		}
		if(fgets(&linebuf[read_pos], (int)read_sz, f)==NULL) done_reading=1;
		else {
			read_pos=strlen(linebuf);
			if(linebuf[read_pos-1]=='\n') {
				linebuf[--read_pos]='\0';
				done_reading=1;
			}
		}
	}
	lineend=&linebuf[read_pos];
	/* all that to read one line.  isn't C fun? :) now comes the parsing :/ */

	/* skip leading whitespace */
	for(optptr=linebuf; optptr<lineend && isspace(*optptr); optptr++);
	/* continue to '=' or EOL, watching for spaces that might precede it */
	for(eqptr=optptr; eqptr<lineend && *eqptr!='='; eqptr++){
		if(isspace(*eqptr) && optend==NULL) optend=eqptr;
		else optend=NULL;
	}
	if(optend==NULL) optend=eqptr;
	--optend;
	/* ^[[:space:]]*=foo is a syntax error */
	if(optptr==eqptr) die(STATE_UNKNOWN, "%s\n", _("Config file error"));
	/* continue from '=' to start of value or EOL */
	for(valptr=eqptr+1; valptr<lineend && isspace(*valptr); valptr++);
	/* continue to the end of value */
	for(valend=valptr; valend<lineend; valend++);
	--valend;
	/* Finally trim off trailing spaces */
	for(; isspace(*valend); valend--);
	/* calculate the length of "--foo" */
	opt_len=(size_t)(1+optend-optptr);
	/* 1-character params needs only one dash */
	if(opt_len==1)
		cfg_len=1+(opt_len);
	else
		cfg_len=2+(opt_len);
	/* if valptr<lineend then we have to also allocate space for "=bar" */
	if(valptr<lineend) {
		equals=value=1;
		val_len=(size_t)(1+valend-valptr);
		cfg_len+=1+val_len;
	}
	/* if valptr==valend then we have "=" but no "bar" */
	else if(valptr==lineend) {
		equals=1;
		cfg_len+=1;
	}
	/* A line with no equal sign isn't valid */
	if(equals==0) die(STATE_UNKNOWN, "%s\n", _("Config file error"));

	/* okay, now we have all the info we need, so we create a new np_arg_list
	 * element and set the argument...
	 */
	optnew=malloc(sizeof(np_arg_list));
	optnew->next=NULL;

	read_pos=0;
	optnew->arg=malloc(cfg_len+1);
	/* 1-character params needs only one dash */
	if(opt_len==1) {
		strncpy(&optnew->arg[read_pos], "-", 1);
		read_pos+=1;
	} else {
		strncpy(&optnew->arg[read_pos], "--", 2);
		read_pos+=2;
	}
	strncpy(&optnew->arg[read_pos], optptr, opt_len); read_pos+=opt_len;
	if(value) {
		optnew->arg[read_pos++]='=';
		strncpy(&optnew->arg[read_pos], valptr, val_len); read_pos+=val_len;
	}
	optnew->arg[read_pos]='\0';

	/* ...and put that to the end of the list */
	if(*optlst==NULL) {
		*optlst=optnew;
	}	else {
		while(opttmp->next!=NULL) {
			opttmp=opttmp->next;
		}
		opttmp->next = optnew;
	}

	free(linebuf);
	return 0;
}

static char *default_file_in_path(void){
	char *config_path, **file;
	char *dir, *ini_file, *tokens;

	if((config_path=getenv("NAGIOS_CONFIG_PATH"))==NULL)
		return NULL;

	if((tokens=strdup(config_path))==NULL)
		die(STATE_UNKNOWN, "%s\n", _("Insufficient Memory"));
	for(dir=strtok(tokens, ":"); dir!=NULL; dir=strtok(NULL, ":")){
		for(file=default_ini_file_names; *file!=NULL; file++){
			if((asprintf(&ini_file, "%s/%s", dir, *file))<0)
				die(STATE_UNKNOWN, "%s\n", _("Insufficient Memory"));
			if(access(ini_file, F_OK)==0){
				free(tokens);
				return ini_file;
			}
		}
	}
	free(tokens);
	return NULL;
}

static char *default_file(void){
	char **p, *ini_file;

	if((ini_file=default_file_in_path())!=NULL)
		return ini_file;
	for(p=default_ini_path_names; *p!=NULL; p++)
		if (access(*p, F_OK)==0)
			return *p;
	return NULL;
}
