ttail/src/ttail_init.c

#include "ttail_init.h"

void usage()
{
	static struct option opts[] = TTAIL_LONG_OPT;
	static char *help[][2] = TTAIL_OPT_HELP;
	size_t i;
	printf("Usage : ttail -d DATE [OPTIONS]\n");
	printf("\t\n");
	printf("Options list\n");
	i=0;
	while(opts[i].name)
	{
		printf("\t-%c, --%s", opts[i].val, opts[i].name);
		if(opts[i].has_arg == required_argument)
		{
			printf("=%s\n",
				help[i][1]?help[i][1]:"ARG");
		}
		else if(opts[i].has_arg == optional_argument)
		{
			printf("[=%s]\n",
				help[i][1]?help[i][1]:"ARG");
		}
		else
		{
			printf("\n");
		}
		printf("\t\t%s\n\n", help[i][0]);
		i++;
	}
}

ttail_t *ttail_init(int argc, char **argv)
{
	ttail_t *res;
	int c, opt_i, ret;
	char *dates[2] = { NULL, NULL };
	char *date;

	res = malloc(sizeof(ttail_t));
	if(!res)
	{
		perror("Unable to allocate memory");
		goto ttail_init_alloc_err;
	}

	opterr = 0;
	optind = 0;
	res->verbose = 0;
	res->fmt = NULL;
	res->flag = 0;
	res->logfile = NULL;
	res->logfile_name = NULL;
	res->logfile_sz = 0;
	res->prefix_sz = -1;
	res->session = NULL;
	memset(&(res->date_min), 0, sizeof(struct tm));
	memset(&(res->date_max), 0, sizeof(struct tm));

	while(1)
	{
		static struct option long_options[] = TTAIL_LONG_OPT;

		c = getopt_long(argc, argv, TTAIL_SHORT_OPT, long_options, &opt_i);
		if(c == -1)
			break;
		
		switch(c)
		{
			case 'v':
				res->verbose++;
				break;
			case 'r':
				if(ttail_set_prefix(res, optarg))
				{
					goto ttail_init_err;
				}
				break;
			case 'p':
				if(res->flag & TTAIL_FLAG_PREFIX)
				{
					fprintf(stderr, "Preffix allready \
set\n");
					goto ttail_init_err;
				}
				res->flag |= TTAIL_FLAG_PREFIX;
				res->prefix_sz = atoi(optarg);
				if(res->prefix_sz <= 0)
				{
					fprintf(stderr, "Prefix size have \
to be > 0");
					goto ttail_init_err;
				}
				break;
			case 'E':
				if(ttail_set_flag_re_ex(res) < 0)
				{
					goto ttail_init_err;
				}
				break;
			case 'I':
				if(ttail_set_flag_re_ci(res) < 0)
				{
					goto ttail_init_err;
				}
				break;
			case 'f':
				if(res->flag & TTAIL_FLAG_FORMAT)
				{
					fprintf(stderr,"Multiple date format \
given\n");
					goto ttail_init_err;
				}
				if(ttail_set_fmt(res, optarg) < 0)
				{
					goto ttail_init_err;
				}

				break;
			case 'l':
				ret = ttail_add_logfile(res, optarg);
				if(ret < 0)
				{
					goto ttail_init_err;
				}
				break;
			case 'd':
			case 'm':
				date = malloc(sizeof(char)*(strlen(optarg)+1));
				if(!date)
				{
					goto ttail_init_err;
				}
				strcpy(date, optarg);
				dates[c=='d'?0:1] = date;
				break;
			case '?':
				optind--;
				goto init_badarg;
				break;
			default:
				fprintf(stderr, "Bad argument\n");
				goto init_badarg;
				
		}
	}
	
	if(optind < argc)
	{
		init_badarg:
		fprintf(stderr, "bad option :");
		while(optind < argc)
		{
			fprintf(stderr, argv[optind++]);
		}
		fprintf(stderr, "\n");
		goto ttail_init_err;
	}

	if(ttail_set_dates(res, dates) < 0)
	{
		goto ttail_init_err;
	}

	return res;

	ttail_init_err:
	if(dates[0]) { free(dates[0]); }
	if(dates[1]) { free(dates[1]); }
	ttail_free(res);
	ttail_init_alloc_err:
	return NULL;
}

int ttail_init_check(ttail_t* t)
{
	size_t i, ret;
	if(t->logfile_sz)
	{
		ret = 0;
		for(i=0; i<t->logfile_sz; i++)
		{
			if(t->logfile[i])
			{
				ret = 1;
				break;
			}
		}
		if(!ret)
		{
			fprintf(stderr, "Unable to read from any of the files \
given as argument\n");
			return -1;
		}
	}
	if(t->flag & TTAIL_FLAG_DATE_MAX)
	{
		fprintf(stderr, "Warning : date-max not yet implemented\n");
	}
	if(!(t->flag & TTAIL_FLAG_DATE_MIN))
	{
		fprintf(stderr, "--date-min -d is mandatory\n");
		return -1;
	}
	if(!(t->flag & TTAIL_FLAG_FORMAT))
	{
		fprintf(stderr, "No date format set nor detected. Abording.\n");
		return -1;
	}
	else if(!t->fmt)
	{
		fprintf(stderr, "Date format flag set but no format found\n");
		return -1;
	}
	return 0;
}

int ttail_add_logfile(ttail_t* res, const char* filename)
{
	void *tmp;
	FILE *fp;
	char *fname;
	int ret, i;

	for(i=0; i<res->logfile_sz; i++)
	{
		if(strcmp(filename, res->logfile_name[i]) == 0)
		{
			fprintf(stderr, "File '%s' allready added\n",
				filename);
			return -1;
		}
	}

	res->logfile_sz++;
	tmp = res->logfile;
	res->logfile = realloc(res->logfile,
		sizeof(FILE*)*res->logfile_sz);
	ret = 0;
	if(!res->logfile)
	{
		perror("Unable to allocate memory for logfiles");
		res->logfile = tmp;
		goto ttail_add_logfile_fpalloc_err;
	}
	fp = fopen(filename, "r");
	if(!fp)
	{
		fprintf(stderr, "Unable to open file : %s\n", filename);
		res->logfile[res->logfile_sz-1] = NULL;
		ret = 1;
	}
	res->logfile[res->logfile_sz-1] = fp;

	tmp = res->logfile_name;
	res->logfile_name = realloc(res->logfile_name,
		sizeof(char*)*res->logfile_sz);
	if(!res->logfile_name)
	{
		perror("Unable to allocate memory for logfiles");
		res->logfile_name = tmp;
		goto ttail_add_logfile_fnalloc_err;

	}
	fname = malloc(sizeof(char)*(strlen(filename)+1));
	if(!fname)
	{
		perror("Unable to allocate memory for logfiles");
		goto ttail_add_logfile_fnalloc_err;
	}
	strcpy(fname, filename);
	res->logfile_name[res->logfile_sz-1] = fname;
	
	return ret;

	ttail_add_logfile_fnalloc_err:
	fclose(res->logfile[res->logfile_sz-2]);
	ttail_add_logfile_fpalloc_err:
	res->logfile_sz--;
	return -1;
}

int ttail_set_prefix(ttail_t* res, const char* regex)
{
	int ret, cflags;
	char *re_errbuff;
	size_t re_errbuff_sz;

	if(res->flag & TTAIL_FLAG_PREFIX)
	{
		fprintf(stderr, "Regex prefix allready set");
		return 1;
	}
	res->flag |= TTAIL_FLAG_PREFIX;
	cflags = 0; /** @todo checks */
	if(res->flag & TTAIL_FLAG_EXTENDED_RE)
	{
		cflags |= REG_EXTENDED;
	}
	if(res->flag & TTAIL_FLAG_CI_RE)
	{
		cflags |= REG_ICASE;
	}
	ret = regcomp(&res->date_prefix, regex, cflags);
	if(!ret)
	{
		return 0;
	}
	/*compilation error */
	res->flag ^= TTAIL_FLAG_PREFIX;
	re_errbuff_sz = regerror(ret,
		&res->date_prefix, NULL, 0);
	re_errbuff = malloc(
		sizeof(char)*re_errbuff_sz);
	if(!re_errbuff)
	{
		perror("Failed to allocate memory for regex compilation \
error message");
		goto ttail_set_prefix_err;
	}
	regerror(ret, &res->date_prefix,
		re_errbuff,
		sizeof(char)*re_errbuff_sz);
	fprintf(stderr, "Regex compilation fails : %s", re_errbuff);

	free(re_errbuff);
	ttail_set_prefix_err:
	return -1;
}

int ttail_set_fmt(ttail_t* t, const char* fmt)
{
	size_t len;
	if(t->flag & TTAIL_FLAG_FORMAT)
	{
		return -1;
	}
	len = strlen(fmt);
	t->fmt = malloc(sizeof(char)*(len+1));
	if(!t->fmt)
	{
		return -1;
	}
	strncpy(t->fmt, fmt, len);
	t->fmt[len] = '\0';
	t->flag |= TTAIL_FLAG_FORMAT;
	return 0;
}

/**@brief This function is used by bot @ref ttail_set_flag_re_ex() and
 *ttail_set_flag_re_ci() function
 *@param t ttail_t*
 *@return -1 on error else 0
 */
static int _ttail_common_set_flag_re(ttail_t* ttail)
{
	if(ttail->flag & TTAIL_FLAG_PREFIX)
	{
		fprintf(stderr, "Regex flags has to be set BEFORE the \
prefix\n");
		return -1;
	}
	return 0;
}

int ttail_set_flag_re_ex(ttail_t* ttail)
{
	if(_ttail_common_set_flag_re(ttail) < 0)
	{
		return -1;
	}
	ttail->flag |= TTAIL_FLAG_EXTENDED_RE;
	return 0;
}

int ttail_set_flag_re_ci(ttail_t* ttail)
{
	if(_ttail_common_set_flag_re(ttail) < 0)
	{
		return -1;
	}
	ttail->flag |= TTAIL_FLAG_CI_RE;
	return 0;
}

int ttail_set_dates(ttail_t* res, char* dates[2])
{
	int c, ret;
	char *date;

	for(c=0;c<2;c++)
	{
		memset(c==0?&(res->date_min):&(res->date_max), 0, \
			sizeof(struct tm));
		if(!dates[c])
		{
			continue;
		}
		if(!(res->flag & TTAIL_FLAG_FORMAT))
		{
			/* no format specified */
			ret = ttail_format_guess(res, dates[c],
				c==0?&(res->date_min):&(res->date_max));
			if(ret < 0)
			{
				fprintf(stderr, "Unable to guess format for \
date '%s'\n", dates[c]);
				return -1;
			}
			res->flag |= c?TTAIL_FLAG_DATE_MAX:TTAIL_FLAG_DATE_MIN;
			continue;
		}
		date = strptime(dates[c], res->fmt, 
			c==0?&(res->date_min):&(res->date_max));
		if(!date)
		{
			fprintf(stderr, "Unable to parse date-%s '%s' with \
format '%s'\n", c==0?"min":"max", dates[c], res->fmt);
			return -1;
		}
		else if(*date != '\0')
		{
			fprintf(stderr, "Leading caracters for date-%s : %s\n",\
				c==0?"min":"max", date);
		}
		res->flag |= c?TTAIL_FLAG_DATE_MAX:TTAIL_FLAG_DATE_MIN;
	}

	if(dates[0]) { free(dates[0]); dates[0] = NULL; }
	if(dates[1]) { free(dates[1]); dates[1] = NULL; }

	return 0;
}

int ttail_format_guess(ttail_t* t, const char* date_str, struct tm* tm)
{
	int i, res;
	char *res_ret, *ret;
	char *fmt[] = TTAIL_DEFAULT_FORMATS;
	struct tm dte;
	
	memset(&dte, 0, sizeof(struct tm));

	if(t->flag & TTAIL_FLAG_FORMAT)
	{
		fprintf(stderr, "Format allready set\n");
		return -2;
	}
	res = -1;
	res_ret = NULL;
	i=0;
	while(fmt[i])
	{
		ret = strptime(date_str, fmt[i], &dte);
		if(ret)
		{
			if(!res_ret || strlen(res_ret) > strlen(ret))
			{
				res_ret = ret;
				res = i;
				if(tm)
				{
					memcpy(tm, &dte, sizeof(struct tm));
				}
				if(t->fmt)
				{
					free(t->fmt);
				}
				t->fmt = malloc(
					sizeof(char)*(strlen(fmt[i])+1));
				if(!t->fmt)
				{
					perror("Unable to allocate memory\
for date format");
					t->flag ^= TTAIL_FLAG_FORMAT;
					return -1;
				}
				strcpy(t->fmt, fmt[i]);
				t->flag |= TTAIL_FLAG_FORMAT;
			}
		}
		i++;
	}
	if(!res_ret)
	{
		if(tm)
		{
			memset(tm, 0, sizeof(struct tm));
		}
		return -1;
	}

	return res;
}

void ttail_free(ttail_t* t)
{
	size_t i;
	if(t->flag & TTAIL_FLAG_PREFIX && t->prefix_sz < 0)
	{
		regfree(&(t->date_prefix));
	}
	for(i=0; i<t->logfile_sz; i++)
	{
		if(t->logfile[i])
		{
			fclose(t->logfile[i]);
		}
		if(t->logfile_name[i])
		{
			free(t->logfile_name[i]);
		}
	}
	free(t->logfile);
	free(t->logfile_name);
	t->logfile_sz = 0;
	if(t->fmt != NULL)
	{
		free(t->fmt);
	}
	free(t);
	optind=0;
}