Logger implementation continuation + tests

include/logger.h

@@ -55,6 +55,11 @@
 #define PYFCGI_LOGGER_FIELD_MAX 24
 #define PYFCGI_LOGGER_FMT_PARSE_ERRSZ 64
 
+#define PYFCGI_LOG_DTM_LEN 10
+#define PYFCGI_LOG_LVL_LEN 7
+#define PYFCGI_LOG_TYP_LEN 7
+#define PYFCGI_LOG_PID_LEN 5
+
 #define SYSLOG_syslog syslog
 #define SYSLOG_vsyslog vsyslog
 #define SYSLOG_EMERG   LOG_EMERG
@@ -65,8 +70,6 @@
 #define SYSLOG_NOTICE  LOG_NOTICE
 #define SYSLOG_INFO    LOG_INFO
 #define SYSLOG_DEBUG   LOG_DEBUG
-static const short SYSLOG_LVLS[8] = {LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
-                                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG};
 
 #undef LOG_EMERG
 #undef LOG_ALERT
@@ -139,6 +142,15 @@ typedef enum pyfcgi_logger_field_type pyfcgi_logger_field_type_e;
 typedef struct strftime_args_s strftime_args_t;
 typedef union pyfcgi_logger_field_args pyfcgi_logger_field_args_u;
 
+
+static const short SYSLOG_LVLS[8] = {LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
+                                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG};
+static const char* PYFCGI_LOGGER_LVLNAME[] = {"Emergency", "Alert", "Critical",
+                                              "Error", "Warning", "Notice",
+					      "Info", "Debug"};
+
+static const char* PYFCGI_LOGGER_TYPNAME[] = {"Global", "Access", "Internal",
+                                              "Worker", "Master"};
 /**@brief Logger configuration
  * @ingroup conf_logger
  */
@@ -299,6 +311,11 @@ int pyfcgi_logger_parse_field(const char**, const char *,
                               pyfcgi_logger_fmt_field_t*,
                               char[PYFCGI_LOGGER_FMT_PARSE_ERRSZ]);
 
+/**@brief Free allocated memory in given field
+ * @param pyfcgi_logger_fmt_field_t* field to free
+ */
+void pyfcgi_logger_field_free(pyfcgi_logger_fmt_field_t*);
+
 /**@brief Given a field pointer return the size option incrementing
  * ptr
  * @warning do not check if the next character is OK, the caller has to
@@ -319,6 +336,12 @@ int pyfcgi_logger_parse_field_sz(const char**, size_t*);
  */
 int pyfcgi_logger_parse_field_dtfmt(const char**, char**);
 
+/**@brief Return a str repr of given loglevel
+ * @warning returned pointer must NOT be freed or modified
+ * @return The loglevel name or NULL if error
+ */
+const char* pyfcgi_logger_value_level(short);
+const char* pyfcgi_logger_value_facility(short);
 
 /**@brief Open a logger
  * @param pyfcgi_logger_t

src/logger.c

@@ -124,7 +124,8 @@ int pyfcgi_logger_parse_format(const char* fmt,
 		}
 		str_start = ptr;
 		while(*ptr && *ptr != '{' && *(ptr+1) != '{')
-		{
+		{ // handling const chr fields
+			//TODO : issue warning/error when unescaped '}' found
 			if(!cur_field->type)
 			{
 				cur_field->type = pyfcgi_logger_field_const;
@@ -186,7 +187,7 @@ int pyfcgi_logger_parse_field(const char** ptr, const char *start,
 	
 	const char *str_start, *field_start;
 	int ret;
-	char **name, **format;
+	char **name, *cname, **format;
 	size_t default_len;
 	pyfcgi_logger_field_type_e *type;
 	char *field_names[] = {"datetime", "level", "facility", "pid", "ident",
@@ -202,33 +203,37 @@ int pyfcgi_logger_parse_field(const char** ptr, const char *start,
 	type = field_types;
 	while(*name)
 	{
-		if(**name != **ptr)
+		cname = *name;
+		if(*cname != **ptr)
 		{
 			name++;
 			type++;
 			continue;
 		}
 		// Name found ?
-		while(**ptr && **name && **ptr != ':' && **ptr != '}')
+		while(**ptr && *cname && **ptr != ':' && **ptr != '}' &&
+		      **ptr == *cname)
 		{
-			if(**ptr != **name)
-			{
-				break;
-			}
 			(*ptr)++;
-			(*name)++;
+			cname++;
 		}
 		if(**ptr == ':' || **ptr == '}')
 		{
 			cur_field->type = *type;
+			break;
 		}
 		else
 		{
+			*name = field_names[6]; // NULL
+			break;
+		}
+	}
+	if(!name)
+	{
 			snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
 				 "unknown field type '%s' chr %ld",
 				 str_start, str_start - start);
 			return 1;
-		}
 	}
 	if(**ptr == ':') { (*ptr)++; } // next option
 	if(pyfcgi_logger_parse_field_sz(ptr, &(cur_field->len)))
@@ -244,7 +249,7 @@ int pyfcgi_logger_parse_field(const char** ptr, const char *start,
 	switch(cur_field->type)
 	{
 		case pyfcgi_logger_field_datetime:
-			default_len = 10;
+			default_len = PYFCGI_LOG_DTM_LEN;
 			cur_field->val = (void*)strftime;
 			format = &(cur_field->args.datetime.format);
 			ret = pyfcgi_logger_parse_field_dtfmt(ptr,format);
@@ -253,16 +258,20 @@ int pyfcgi_logger_parse_field(const char** ptr, const char *start,
 			}
 			break;
 		case pyfcgi_logger_field_level:
-			default_len = 7;
+			default_len = PYFCGI_LOG_LVL_LEN;
+			cur_field->val = (void*)pyfcgi_logger_value_level;
 			break;
 		case pyfcgi_logger_field_facility:
-			default_len = 6;
+			default_len = PYFCGI_LOG_TYP_LEN;
+			cur_field->val = (void*)pyfcgi_logger_value_facility;
 			break;
 		case pyfcgi_logger_field_pid:
-			default_len = 5;
+			default_len = PYFCGI_LOG_PID_LEN;
+			cur_field->val = &(PyFCGI_conf.context.pid);
 			break;
 		case pyfcgi_logger_field_ident:
 			default_len = 0;
+			cur_field->val = &(PyFCGI_conf.logs.ident);
 			break;
 		case pyfcgi_logger_field_msg:
 			cur_field->known_length = 0;
@@ -281,6 +290,34 @@ int pyfcgi_logger_parse_field(const char** ptr, const char *start,
 	return 0;
 }
 
+void pyfcgi_logger_field_free(pyfcgi_logger_fmt_field_t* field)
+{
+	switch(field->type)
+	{
+		case pyfcgi_logger_field_const:
+			if(field->val)
+			{
+				free(field->val);
+			}
+			break;
+		case pyfcgi_logger_field_datetime:
+			if(field->args.datetime.format)
+			{
+				free(field->args.datetime.format);
+			}
+			break;
+		case pyfcgi_logger_field_null:
+		case pyfcgi_logger_field_level:
+		case pyfcgi_logger_field_facility:
+		case pyfcgi_logger_field_pid:
+		case pyfcgi_logger_field_ppid:
+		case pyfcgi_logger_field_ident:
+		case pyfcgi_logger_field_msg:
+			break;
+	}
+}
+
+
 int pyfcgi_logger_parse_field_dtfmt(const char** ptr, char** format)
 {
 	const char *fmt;
@@ -330,6 +367,29 @@ int pyfcgi_logger_parse_field_sz(const char **ptr, size_t *size)
 	return 0;
 }
 
+const char* pyfcgi_logger_value_level(short lvl)
+{
+	short idx;
+	idx = (lvl & 0xF0) >> 4;
+	if(idx < 0 || idx >= sizeof(PYFCGI_LOGGER_LVLNAME))
+	{
+		return NULL;
+	}
+	return PYFCGI_LOGGER_LVLNAME[idx];
+}
+
+
+const char* pyfcgi_logger_value_facility(short typ)
+{
+	short idx;
+	idx = typ & 0x0F;
+	if(idx < 0 || idx >= sizeof(PYFCGI_LOGGER_TYPNAME))
+	{
+		return NULL;
+	}
+	return PYFCGI_LOGGER_TYPNAME[idx];
+}
+
 int pyfcgi_logger_open(pyfcgi_logger_t *logger)
 {
 	if( (logger->fd = open(logger->filename,

tests/check_logger.c

@@ -48,6 +48,7 @@ START_TEST(test_logger_parse_field_dtfmt_default)
 	ck_assert_int_eq(ret, 0);
 	ck_assert_str_eq(fmt, PYFCGI_LOGGER_TIME_FMT_DEFAULT);
 	ck_assert_ptr_eq(ptr, orig+1);
+	free(fmt);
 }
 END_TEST
 
@@ -95,7 +96,7 @@ START_TEST(test_logger_parse_field_datetime_default)
 		ck_assert_int_eq(ret, 0);
 		ck_assert_int_eq(field.type, pyfcgi_logger_field_datetime);
 		ck_assert_int_ne(field.known_length, 0);
-		ck_assert_int_eq(field.len, 10);
+		ck_assert_int_eq(field.len, PYFCGI_LOG_DTM_LEN);
 		ck_assert_ptr_eq(field.val, strftime);
 		ck_assert_str_eq(field.args.datetime.format,
 		                 PYFCGI_LOGGER_TIME_FMT_DEFAULT);
@@ -128,15 +129,43 @@ START_TEST(test_logger_parse_field_sz)
 }
 END_TEST
 
-START_TEST(test_logger_parse_field_Tdatetime)
+START_TEST(test_logger_parse_field_dtfmt)
+{
+	int ret;
+	size_t len;
+	char **val, **ptr, *fmt;
+	char *_vals[] = {"%fdc}", "123}", "4}}foo}", NULL};
+
+	val = _vals;
+	while(*val)
+	{
+		ptr = val;
+		len = strlen(*val);
+
+		ret = pyfcgi_logger_parse_field_dtfmt((const char**)&ptr, &fmt);
+		*val[len-1] = '\0'; //deleting leading '}' to get expected result
+		ck_assert_int_eq(ret, 0);
+		ck_assert_ptr_ne(fmt, *val);
+		ck_assert_str_eq(fmt, *val);
+		ck_assert_ptr_eq(ptr, *val+len-1);
+		free(fmt);
+		val++;
+	}
+
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_datetime)
 {
 	int ret, *len;
 	char *ptr, **orig, **fmt, err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
 	pyfcgi_logger_fmt_field_t field;
 	char *vals[] = {"datetime:42}", "datetime::%s%F}",
-	                "datetime:42:COUCOU}", NULL};
-	int _len[] = {42, 10, 42};
-	char *_fmt[] = {PYFCGI_LOGGER_TIME_FMT_DEFAULT, "%s%F", "COUCOU"};
+	                "datetime:42:COUCOU}",
+			"dat:32:FOO}", "d::BAR}", NULL};
+	int _len[] = {42, PYFCGI_LOG_DTM_LEN, 42, 32, PYFCGI_LOG_DTM_LEN};
+	char *_fmt[] = {PYFCGI_LOGGER_TIME_FMT_DEFAULT, "%s%F", "COUCOU", "FOO",
+	                "BAR"};
 
 	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
 	
@@ -147,7 +176,6 @@ START_TEST(test_logger_parse_field_Tdatetime)
 	{
 		ptr = *orig;
 
-dprintf(2, "ORIG='%s'\n", *orig);
 		ret = pyfcgi_logger_parse_field((const char**)&ptr,
 		                                (const char*)ptr, &field,
 						err);
@@ -169,6 +197,162 @@ dprintf(2, "ORIG='%s'\n", *orig);
 }
 END_TEST
 
+START_TEST(test_logger_parse_field_level)
+{
+	int ret;
+	char **val, **ptr;
+	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	char *vals[] = {"level}", "l}", "leve}", NULL};
+	pyfcgi_logger_fmt_field_t field;
+
+	val = vals;
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	while(*val)
+	{
+		ptr = val;
+		ret = pyfcgi_logger_parse_field((const char**)ptr,
+		                                (const char*)*ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_level);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, PYFCGI_LOG_LVL_LEN);
+		ck_assert_ptr_eq(field.val, pyfcgi_logger_value_level);
+		val++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_facility)
+{
+	int ret;
+	char **val, **ptr;
+	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	char *vals[] = {"facility}", "f}", "fac}", NULL};
+	pyfcgi_logger_fmt_field_t field;
+
+	val = vals;
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	while(*val)
+	{
+		ptr = val;
+		ret = pyfcgi_logger_parse_field((const char**)ptr,
+		                                (const char*)*ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_facility);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, PYFCGI_LOG_TYP_LEN);
+		ck_assert_ptr_eq(field.val, pyfcgi_logger_value_facility);
+		val++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_pid)
+{
+	int ret;
+	char **val, **ptr;
+	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	char *vals[] = {"pid}", "p}", "pi}", NULL};
+	pyfcgi_logger_fmt_field_t field;
+
+	val = vals;
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	while(*val)
+	{
+		ptr = val;
+		ret = pyfcgi_logger_parse_field((const char**)ptr,
+		                                (const char*)*ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_pid);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, PYFCGI_LOG_PID_LEN);
+		ck_assert_ptr_eq(field.val, (&PyFCGI_conf.context.pid));
+		val++;
+	}
+}
+END_TEST
+
+START_TEST(test_logger_parse_field_ident)
+{
+	int ret;
+	char **val, **ptr;
+	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	char *vals[] = {"ident}", "i}", "id}", NULL};
+	pyfcgi_logger_fmt_field_t field;
+
+	val = vals;
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	while(*val)
+	{
+		ptr = val;
+		ret = pyfcgi_logger_parse_field((const char**)ptr,
+		                                (const char*)*ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_ident);
+		ck_assert_int_ne(field.known_length, 0);
+		ck_assert_int_eq(field.len, 0);
+		ck_assert_ptr_eq(field.val, (&PyFCGI_conf.logs.ident));
+		val++;
+	}
+}
+END_TEST
+
+
+START_TEST(test_logger_parse_field_msg)
+{
+	int ret;
+	char **val, **ptr;
+	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	char *vals[] = {"msg}", "m}", "ms}", NULL};
+	pyfcgi_logger_fmt_field_t field;
+
+	val = vals;
+	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
+
+	while(*val)
+	{
+		ptr = val;
+		ret = pyfcgi_logger_parse_field((const char**)ptr,
+		                                (const char*)*ptr, &field,
+						err);
+		if(ret)
+		{
+			dprintf(2, "ERROR : '%s'\n", err);
+		}
+		ck_assert_int_eq(ret, 0);
+		ck_assert_int_eq(field.type, pyfcgi_logger_field_msg);
+		ck_assert_int_eq(field.known_length, 0);
+		ck_assert_int_eq(field.len, 0);
+		ck_assert_ptr_eq(field.val, NULL);
+		val++;
+	}
+}
+END_TEST
+
 Suite * logger_suite(void)
 {
 	Suite *s;
@@ -181,15 +365,20 @@ Suite * logger_suite(void)
 	//tcase_add_test(tc_init, test_logger_format_add);
 	suite_add_tcase(s, tc_init);
 
-	tc_fmt_default = tcase_create("Logger format default values");
+	tc_fmt_default = tcase_create("Logger format parsing default values");
 	tcase_add_test(tc_fmt_default, test_logger_parse_field_dtfmt_default);
 	tcase_add_test(tc_fmt_default, test_logger_parse_field_sz_default);
 	tcase_add_test(tc_fmt_default, test_logger_parse_field_datetime_default);
 	suite_add_tcase(s, tc_fmt_default);
 
-	tc_fmt = tcase_create("Logger format");
-	tcase_add_test(tc_fmt_default, test_logger_parse_field_sz);
-	tcase_add_test(tc_fmt_default, test_logger_parse_field_Tdatetime);
+	tc_fmt = tcase_create("Logger format parsing");
+	tcase_add_test(tc_fmt, test_logger_parse_field_sz);
+	tcase_add_test(tc_fmt, test_logger_parse_field_datetime);
+	tcase_add_test(tc_fmt, test_logger_parse_field_level);
+	tcase_add_test(tc_fmt, test_logger_parse_field_facility);
+	tcase_add_test(tc_fmt, test_logger_parse_field_pid);
+	tcase_add_test(tc_fmt, test_logger_parse_field_ident);
+	tcase_add_test(tc_fmt, test_logger_parse_field_msg);
 	suite_add_tcase(s, tc_fmt);
 
 	return s;
@@ -205,7 +394,9 @@ int main(void)
 	sr = srunner_create(s);
 	
 	//srunner_set_fork_status(sr, CK_NOFORK);
-	srunner_run_all(sr, CK_NORMAL);
+	//srunner_run_all(sr, CK_NORMAL);
+	//srunner_run_all(sr, CK_ENV);
+	srunner_run_all(sr, CK_VERBOSE);
 	nfailed = srunner_ntests_failed(sr);
 	srunner_free(sr);
 	return (!nfailed)?EXIT_SUCCESS:EXIT_FAILURE;