Started to implement file search op

configure.ac

 AM_INIT_AUTOMAKE
 
 #configure options
+AC_ARG_ENABLE([huge-file],[  --enable-huge-file to enable huge file support],
+[case "${enableval}" in
+	yes) huge_file=true ;;
+	no)  huge_file=false ;;
+	*) AC_MSG_ERROR([bad value ${enableval} for --enable-huge-file]) ;;
+esac],[huge_file=false])
+AM_CONDITIONAL([HUGEFILE], [test x$huge_file = xtrue])
 AC_ARG_ENABLE([debug],[  --enable-debug turn on debugging],
 [case "${enableval}" in
 	yes) debug=true ;;
 	AX_CHECK_CFLAGS([-fgnu89-inline])
 ])
 AX_CHECK_CFLAGS([-D_XOPEN_SOURCE -D_GNU_SOURCE])
-
+#Condition done in Makefile.am
+#AS_IF([test x$huge_file = xtrue], [
+#AX_CHECK_CFLAGS([-DTTAIL_HUGE_FILE])
+#],[])
 
 # Checks for library functions.
 AC_FUNC_MALLOC

src/Makefile.am

 
 libttail_init_a_SOURCES = ttail_init.c
 libttail_search_a_SOURCES = ttail_search.c
-libttail_search_a_CFLAGS = @CFLAGS@ -D_NOSTATIC
 ttail_SOURCES = main.c ttail_init.c ttail_search.c
+if HUGEFILE
+ttail_CFLAGS = @CFLAGS@ -DTTAIL_HUGE_FILE
+libttail_search_a_CFLAGS = @CFLAGS@ -DTTAIL_HUGE_FILE
+libttail_init_a_CFLAGS = @CFLAGS@ -DTTAIL_HUGE_FILE
+endif
+
+if DEBUG
+if HUGEFILE
+bin_PROGRAMS += ttail_no_huge
+ttail_no_huge_SOURCES = main.c ttail_init.c ttail_search.c
+else
+bin_PROGRAMS += ttail_huge
+ttail_huge_SOURCES = main.c ttail_init.c ttail_search.c
+ttail_huge_CFLAGS = @CFLAGS@ -DTTAIL_HUGE_FILE
+endif
+endif

src/include/config.h.in

 /* src/include/config.h.in.  Generated from configure.ac by autoheader.  */
 
 /* used by libcheck to disable static functions */
-#ifdef _NOSTATIC
-#define _static
-#else
-#define _static static
-#endif
 
 #undef TTAIL_FMT_REGEX
 

src/include/ttail.h

 #include <time.h>
 #include <unistd.h>
 
+typedef struct _ttail_s ttail_t;
+
+#include "config.h"
+#include "ttail_search.h"
+
 #define TTAIL_FLAG_PREFIX 1
 #define TTAIL_FLAG_DATE_MIN 2
 #define TTAIL_FLAG_DATE_MAX 4
 
 	/*! A strptime format matching datetime in logfile */
 	char *fmt;
-
+	
+	/*! Date min set from cli */
 	struct tm date_min;
 	struct tm date_max;
 
 	int verbose;
+	/**@brief Status flag
+	 *
+	 *see TTAIL_FLAG_*
+	 */
 	int flag;
+
+	ttail_search_t *session;
 };
-typedef struct _ttail_s ttail_t;
 
 #endif

src/include/ttail_search.h

-#ifndef _ttail_init_h__
-#define _ttail_init_h__
+#ifndef _ttail_search_h__
+#define _ttail_search_h__
 
+#include <errno.h>
 #include <string.h>
 #include <time.h>
 #include <regex.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+typedef union _ttail_search_u ttail_search_t;
 
 #include "config.h"
 #include "ttail.h"
 
+typedef char* (*ttail_search_subst_f)(ttail_t*, const char*);
+
+typedef struct _ttail_search_file_s ttail_search_file_t;
+typedef struct _ttail_search_stdin_s ttail_search_stdin_t;
+
+/*<! Private search session for logfiles */
+struct _ttail_search_file_s
+{
+	/*<! logfile sizes */
+	off_t *file_sz;
+	#ifdef TTAIL_HUGE_FILE
+	/*<! Shift width to apply on size to compute stuff */
+	short sz_div;
+	#endif
+	/*<! Computed files start size */
+	off_t *vfile;
+	/*<! Computed file sizes sum */
+	off_t vsz;
+	/*<! Computed position */
+	off_t vpos;
+};
+
+/*<! Private search session for stdin */
+struct _ttail_search_stdin_s
+{
+	char *buff;
+	size_t buff_sz;
+};
+
+/**@brief Search session is an union depending in the search method
+ * employed
+ */
+union _ttail_search_u
+{
+	ttail_search_file_t file;
+	ttail_search_stdin_t std;
+};
+
 /**@brief Comparison results
  *
  * -1 if a < b, 1 if a > b, 0 if a == b, -2 if exception
  */
 typedef int ttail_cmp_res;
 
+/**@brief Begin a search session placing it in a ready to print situation
+ *@param ttail_t*
+ *@return 0 if ok -1 if fatal error 1 if not found
+ */
+int ttail_search_closest(ttail_t*);
+
+/**@brief @ref ttail_search_closest() implementation for logfiles
+ *@param ttail_t*
+ *@return 0 if ok -1 if fatal error 1 if not found
+ */
+int _ttail_search_closest_files(ttail_t*);
+int _ttail_search_closest_files_init(ttail_t*);
+int _ttail_search_closest_files_set_fsizes(ttail_t*);
+
+/**@brief @ref ttail_search_closest() implementation for stdin
+ *@param ttail_t*
+ *@return 0 if ok -1 if fatal error 1 if not found
+ */
+int _ttail_search_closest_stdin(ttail_t*);
+
+/**@brief Attempt to reopen a file
+ *@param ttail_t* ttail
+ *@param size_t id file id in ttail
+ *@return 0 on success, -1 on failure and errno is set
+ *@throw EINVAL if id is too big
+ */
+int _ttail_file_reopen(ttail_t*, size_t);
+
 /**@brief Loglines comparison function
  *@param ttail_t* ttail
  *@param const char* logline a
 /**@brief Apply the choosen substitution to the logline
  *@param ttail_t* ttail
  *@param const char* logline
- *@return a pointer on the begining of the subst string
+ *@return a pointer on the end of the subst string
+ */
+const char* ttail_logline_subst(ttail_t*, const char*);
+
+/**@brief Regex logline prefix substitution
+ *@param ttail_t* ttail
+ *@param const char* logline
+ *@return a pointer on the end of the subst string
+ */
+const char* _ttail_logline_subst_re(ttail_t*, const char*);
+
+/**@brief Static len logline prefix substitution
+ *@param ttail_t* ttail
+ *@param const char* logline
+ *@return a pointer on the end of the subst string
  */
-_static const char* ttail_logline_subst(ttail_t*, const char*);
+const char* _ttail_logline_subst_len(ttail_t*, const char*);
 
 #endif

src/ttail_search.c

 #include "ttail_search.h"
 
+int ttail_search_closest(ttail_t* ttail)
+{
+	if(ttail->session != NULL)
+	{
+		fprintf(stderr, "A session is allready started\n");
+		return -1;
+	}
+	ttail->session = (ttail_search_t*)malloc(ttail->logfile_sz?
+		sizeof(ttail_search_file_t):sizeof(ttail_search_stdin_t));
+	if(!ttail->session)
+	{
+		perror("Unable to allocate memory for search session");
+		return -1;
+	}
+	return ttail->logfile_sz?\
+		_ttail_search_closest_files(ttail):\
+		_ttail_search_closest_stdin(ttail);
+}
+
+int _ttail_search_closest_files(ttail_t* t)
+{
+	return _ttail_search_closest_files_init(t);
+}
+
+int _ttail_search_closest_files_init(ttail_t* t)
+{
+	struct stat stat;
+	FILE *fp;
+	size_t i;
+	off_t *file_sz;
+
+	file_sz = malloc(sizeof(off_t)*t->logfile_sz);
+	if(!file_sz)
+	{
+		perror("Unable to allocate memory for file sizes");
+		goto _ttail_search_closest_files_alloc_err;
+	}
+	t->session->file.file_sz = file_sz;
+	#ifdef HUGEFILE
+	t->session->file.sz_div = 0;
+	#endif
+
+	for(i=0;i<t->logfile_sz;i++)
+	{
+		fp = t->logfile[i];
+		if(!fp)
+		{
+			if(_ttail_file_reopen(t,i))
+			{
+				file_sz[i] = 0;
+				continue;
+			}
+		}
+		if(fstat(fileno(fp), &stat))
+		{
+			perror("Unable to get file size");
+			goto _ttail_search_closest_files_err;
+		}
+		file_sz[i] = stat.st_size;
+	}
+	/* we got all real size, determining if we need a divisor */
+	/*
+	 * not implemented
+	 */
+
+	_ttail_search_closest_files_err:
+	free(file_sz);
+	t->session->file.file_sz = NULL;
+	_ttail_search_closest_files_alloc_err:
+	return -1;
+}
+
+int _ttail_search_closest_files_set_fsizes(ttail_t* t)
+{
+	size_t i;
+	off_t *vfile, *vsz;
+	vfile = malloc(sizeof(off_t)*t->logfile_sz);
+	if(!vfile)
+	{
+		perror("Unable to allocate memory for file size sum");
+		return -1;
+	}
+	t->session->file.vfile = vfile;
+	vsz = &(t->session->file.vsz);
+	*vsz = 0;
+	for(i=0; i<t->logfile_sz;i++)
+	{
+		vfile[i] = *vsz;
+		#ifdef HUGEFILE
+		vsz += t->session->file.file_sz[i] >> t->session->file.sz_div;
+		#else
+		vsz += t->session->file.file_sz[i];
+		#endif
+	}
+	t->session->file.vpos = 0;
+	return 0;
+}
+
+int _ttail_file_reopen(ttail_t* t, size_t id)
+{
+	if(t->logfile[id])
+	{
+		fclose(t->logfile[id]);
+	}
+	t->logfile[id] = fopen(t->logfile_name[id], "r");
+	if(!t->logfile[id] && t->verbose > 2)
+	{
+		fprintf(stderr, "Unable to reopen '%s'\n",
+			t->logfile_name[id]);
+	}
+	return t->logfile[id]?0:-1;
+}
+
+int _ttail_search_closest_stdin(ttail_t* t)
+{
+	fprintf(stderr, "Search on stdin not implemented yet");
+	return -1;
+}
+
 int ttail_logline2date(ttail_t* ttail, const char* logline, struct tm* tm)
 {
 	ttail_logline_subst(ttail, logline);
 	return 0;
 }
 
-_static const char* ttail_logline_subst(ttail_t* ttail, const char* logline)
+const char* ttail_logline_subst(ttail_t* ttail, const char* logline)
 {
 	return logline;
 }

tests/ttail_search_check.c

 #include <check.h>
+#include <libgen.h>
 
 #include "ttail.h"
 #include "ttail_search.h"
 
 ttail_t *ttail;
-#define __Fname_sz 5
-#define FNAME_NO_EXIST 0
-#define FNAME_EXIST 1
 
-START_TEST (test_search_subst)
+char *samples[5] = { "./samples/1.log", "./samples/2.log", "./samples/3.log",\
+	"./samples/4.log", "./samples/5.log"};
+off_t samples_sz[5] = { 442, 141, 893, 2587, 2310 };
+
+
+void setup_closest(void)
+{
+
+}
+
+void teardown_closest(void)
+{
+
+}
+
+START_TEST (test_search_closest)
 {
 	ttail_logline_subst(ttail, "Hello world !");
 }
 Suite * ttail_search_suite(void)
 {
 	Suite *s;
-	TCase *tc_search_subst;
+	TCase *tc_search_closest;
 
 	s = suite_create("ttail search checks");
-	tc_search_subst = tcase_create("ttail_logline_subst checks");
-	/*
-	tcase_add_checked_fixture(tc_serch_,
-		setup_ttail_empty, teardown_ttail);
-	*/
-	tcase_add_test(tc_search_subst, test_search_subst);
-
-	suite_add_tcase(s, tc_search_subst);
+	tc_search_closest = tcase_create("ttail_logline_closest checks");
+	tcase_add_checked_fixture(tc_search_closest,
+		setup_closest, teardown_closest);
+	tcase_add_test(tc_search_closest, test_search_closest);
+
+	suite_add_tcase(s, tc_search_closest);
 	return s;
 }
 
-int main(void)
+int main(int argc, char **argv)
 {
 	int number_failed = 0;
 	SRunner *sr;
 
+	chdir(dirname(argv[0])); /* move in ./tests dir */
+
 	sr = srunner_create(ttail_search_suite());
 	srunner_set_fork_status(sr, CK_FORK);