Starts implementation of logger format parsing

include/conf.h

@@ -26,6 +26,8 @@
  * @see struct_pyfcgi_conf_s
  * @ingroup conf_internal */
 
+#include "logger.h"
+
 /**@defgroup ret_status Function & process return status
  */
 #define PYFCGI_ERR 16
@@ -43,7 +45,8 @@ typedef struct pyfcgi_conf_logger_s pyfcgi_conf_logger_t;
 typedef struct pyfcgi_context_s pyfcgi_context_t;
 
 struct pyfcgi_context_s {
-	int foo;
+	pid_t pid;
+	pid_t ppid;
 };
 
 /**@brief Structure containing configuration
@@ -73,6 +76,7 @@ struct pyfcgi_conf_s
 	 * @ingroupe conf_glob */
 	pyfcgi_conf_logger_t logs;
 
+	/**@brief Context informations */
 	pyfcgi_context_t context;
 };
 

include/logger.h

@@ -28,6 +28,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdio.h>
+#include <time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -51,6 +52,9 @@
 /**@ingroup log_facility */
 #define LOG_MASTER 8
 
+#define PYFCGI_LOGGER_FIELD_MAX 24
+#define PYFCGI_LOGGER_FMT_PARSE_ERRSZ 64
+
 #define SYSLOG_syslog syslog
 #define SYSLOG_vsyslog vsyslog
 #define SYSLOG_EMERG   LOG_EMERG
@@ -61,8 +65,8 @@
 #define SYSLOG_NOTICE  LOG_NOTICE
 #define SYSLOG_INFO    LOG_INFO
 #define SYSLOG_DEBUG   LOG_DEBUG
-const short SYSLOG_LVLS[8] = {LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
-                              LOG_WARNING, LOG_NOTICE, LOG_INFO, 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
@@ -116,7 +120,10 @@ const short SYSLOG_LVLS[8] = {LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
 #define PYFCGI_LOG_FRETRY 2
 /**@brief Exit if failure
  * @ingroup cong_logger_flags */
-#define PYFCG_LOG_FEXIT_ONFAIL 4
+#define PYFCGI_LOG_FEXIT_ONFAIL 4
+
+#define PYFCGI_LOGGER_TIME_FMT_DEFAULT "%F %T%z"
+
 
 /**@brief Log level mask
  * @ingroup conf_logger
@@ -125,6 +132,12 @@ const short SYSLOG_LVLS[8] = {LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
 typedef unsigned char logmask_t;
 typedef unsigned char loglvl_t;
 typedef struct pyfcgi_logger_s pyfcgi_logger_t;
+typedef struct pyfcgi_logger_format_s pyfcgi_logger_format_t;
+typedef struct pyfcgi_logger_fmt_field_s pyfcgi_logger_fmt_field_t;
+typedef union pyfcgi_logger_fmt_field_u pyfcgi_logger_fmt_value_t;
+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;
 
 /**@brief Logger configuration
  * @ingroup conf_logger
@@ -166,8 +179,92 @@ struct pyfcgi_logger_s
 	size_t fmt_id;
 };
 
+/**@defgroup conf_logger_format Logline format
+ * @ingroup conf_logger
+ * A small description langage allows to describe wanted logline format.
+ * A format is a string with special markup indicating fields. Fields markup
+ * are surrounded by '{' and '}' chr. This markup can be divided in multiple
+ * subfields separated by ':' chr, but the first field is always the field
+ * name.
+ *
+ * Valid fields are :
+ * - {datetime:SIZE:FMT} defines a format and a constant length for date
+ * string. By default %F %T%z ISO 8601 date format  + time + tz
+ * see @ref PYFCGI_LOGGER_TIME_FMT_DEFAULT
+ * - {level} the loglevel (with a constant length of 7)
+ * - {facility} the log facility (constant length od 6)
+ * - {pid:SIZE} PID with a constant length for pid field
+ * - {ident} the defined ident (size is processed when set)
+ * - {msg} the log message (can only appears once)
+ *
+ * @note You can escape '{' and '}' by using '{{' and '}}'
+ * @note There is a maximum of 24 fields by format (see 
+ * @note All fields can be abbreviate to one character
+ * @ref PYFCGI_LOGGER_FIELD_MAX )
+ */
+
+struct strftime_args_s
+{
+	//char **s; // field.buf_ptr
+	//size_t max; // field.len
+	char *format;
+	//const struct tm *tm; // fecthed each time
+};
+
+union pyfcgi_logger_field_args
+{
+	strftime_args_t datetime;
+};
+
+/**@brief Logger format field's type
+ * @ingroup conf_logger_format */
+enum pyfcgi_logger_field_type
+{
+	pyfcgi_logger_field_null = 0,
+	pyfcgi_logger_field_const = -1,
+	pyfcgi_logger_field_datetime = 1,
+	pyfcgi_logger_field_level = 2,
+	pyfcgi_logger_field_facility = 3,
+	pyfcgi_logger_field_pid = 4,
+	pyfcgi_logger_field_ppid = 5,
+	pyfcgi_logger_field_ident = 6,
+	pyfcgi_logger_field_msg = 7,
+};
+
+/**@brief Logger format field data
+ * @ingroup conf_logger_format */
+struct pyfcgi_logger_fmt_field_s
+{
+	pyfcgi_logger_field_type_e type;
+
+	short known_length;
+	size_t len;
+
+	/** @brief pointer on value (interpreted given field type) */
+	void *val;
+	pyfcgi_logger_field_args_u args;
+	/**@brief Points in prefix or sufix buffer */
+	char *buf_ptr;
+};
+
+/**@brief Logger format data
+ * @ingroup conf_logger_format */
+struct pyfcgi_logger_format_s
+{
+	/**@brief Stores data about fields */
+	pyfcgi_logger_fmt_field_t fields[PYFCGI_LOGGER_FIELD_MAX];
+	/**@brief Preallocated buffer for prefix & suffix */
+	char *buf;
+	/**@brief Message prefix */
+	char *prefix;
+	/**@brief Message suffix */
+	char *suffix;
+};
+
 #include "conf.h"
 
+int pyfcgi_logger_init();
+
 /**@brief Add a new logger
  * @param char* filename
  * @param logmask_t loglvl a mask indicating wich loglevels should be logged
@@ -181,10 +278,50 @@ int pyfcgi_logger_add(const char*, logmask_t, logmask_t, const char*);
  * @param size_t* idx if not NULL, will contain the format index
  * @return 0 if OK
  */
-int pyfcgi_logger_add_format(const char*, size_t*);
+int pyfcgi_logger_format_add(const char*, size_t*);
+
+/**@brief Parse a format string and populate corresponding 
+ * @ref struct pyfgci_logger_format_s
+ * @param const char* fmt string
+ * @param pyfcgi_logger_format_t* fmt_data
+ * @return 0 if no errors
+ */
+int pyfcgi_logger_parse_format(const char*, pyfcgi_logger_format_t*);
+
+/**@brief Parse a field string and populate corresponding
+ * @ret struct pyfcgi_logger_field_s
+ * @param const char ** ptr on current format pointer
+ * @param char * if not NULL and parse error occurs, this string
+ * will be set
+ * @return 0 if no errors and 1 if parse error
+ */
+int pyfcgi_logger_parse_field(const char**, const char *,
+                              pyfcgi_logger_fmt_field_t*,
+                              char[PYFCGI_LOGGER_FMT_PARSE_ERRSZ]);
+
+/**@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
+ * do it
+ * @param char** pointer on format
+ * @param size_t* size if found will be set to size option. if not found set to
+ * 0
+ * @return 0 if no error
+ */
+int pyfcgi_logger_parse_field_sz(const char**, size_t*);
+
+/**@brief Alloc memory by parsing & strdup the strftime format found
+ * in field. If not found use default format
+ * @note set the @ref struct pyfcgi_logger_fmt_field_s.args field
+ * @param const char** ptr
+ * @param char** format
+ * @return 
+ */
+int pyfcgi_logger_parse_field_dtfmt(const char**, char**);
+
 
 /**@brief Open a logger
- * @param pyfcgi_logger_t*
+ * @param pyfcgi_logger_t
  * @return 0 if no errors
  */
 int pyfcgi_logger_open(pyfcgi_logger_t*);

src/logger.c

@@ -1,5 +1,13 @@
 #include "logger.h"
 
+int pyfcgi_logger_init()
+{
+	pyfcgi_conf_logger_t *conf;
+	conf = &PyFCGI_conf.logs;
+	memset(conf, 0, sizeof(pyfcgi_conf_logger_t));
+	return 0;
+}
+
 int pyfcgi_logger_add(const char *filename, logmask_t loglvl, logmask_t logtyp,
                       const char *format)
 {
@@ -18,12 +26,13 @@ int pyfcgi_logger_add(const char *filename, logmask_t loglvl, logmask_t logtyp,
 		return PYFCGI_ERR;
 	}
 
-	if(pyfcgi_logger_add_format(format, &(logger.fmt_id)))
+	if(pyfcgi_logger_format_add(format, &(logger.fmt_id)))
 	{
 		return PYFCGI_FATAL;
 	}
 	if(!logger.filename)
 	{
+		err = errno;
 		err_fmt = "Unable to duplicate logger filename : %s";
 		goto err;
 	}
@@ -53,7 +62,7 @@ err:
 	return PYFCGI_FATAL;	
 }
 
-int pyfcgi_logger_add_format(const char* format, size_t* idx)
+int pyfcgi_logger_format_add(const char* format, size_t* idx)
 {
 	char *fmt;
 	size_t i;
@@ -90,6 +99,233 @@ int pyfcgi_logger_add_format(const char* format, size_t* idx)
 	return 0;
 }
 
+int pyfcgi_logger_parse_format(const char* fmt,
+                               pyfcgi_logger_format_t* fmt_data)
+{
+	const char *ptr, *str_start;
+	int err;
+	char reason_err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
+	unsigned char nfield;
+	pyfcgi_logger_fmt_field_t *cur_field;
+
+	memset(fmt_data, 0, sizeof(pyfcgi_logger_format_t));
+	ptr = fmt;
+	nfield = 0;
+	cur_field = fmt_data->fields;
+
+	while(*ptr)
+	{
+		if(nfield >= PYFCGI_LOGGER_FIELD_MAX)
+		{
+			//TODO error truncate !
+			break;
+		}
+		str_start = ptr;
+		while(*ptr && *ptr != '{' && *(ptr+1) != '{')
+		{
+			if(!cur_field->type)
+			{
+				cur_field->type = pyfcgi_logger_field_const;
+				cur_field->known_length = 1;
+				cur_field->len = 0;
+			}
+			if(*ptr == '{' && *(ptr+1) == '{')
+			{
+				cur_field->len++;
+				ptr++;
+			}
+			cur_field->len++;
+			ptr++;
+		}
+		if(cur_field->len)
+		{
+			cur_field->val = strndup(str_start, cur_field->len);
+			if(!cur_field->val)
+			{
+				err = errno;
+				pyfcgi_log(LOG_ALERT,
+				           "Unable to strdup part of format : %s",
+					   strerror(err));
+				goto exit_err;
+			}
+			nfield++;
+			cur_field = &(fmt_data->fields[nfield]); // next_field
+			continue; // to check nfield
+		}
+		if(*ptr == '{') //should be this or '\0'...
+		{
+			ptr++;
+			if( (1 == pyfcgi_logger_parse_field(&ptr, fmt, 
+			                                    cur_field, 
+			                                    reason_err)) )
+			{
+				goto parse_err;
+			}
+		}
+		ptr++;
+	};
+	
+
+	return 0;
+
+parse_err:
+	pyfcgi_log(LOG_ERR, "Logger format parse error at chr %ld : %s",
+	           ptr - fmt, reason_err);
+exit_err:
+	//TODO free const str from fields
+	memset(fmt_data, 0, sizeof(pyfcgi_logger_format_t));
+	return PYFCGI_ERR;
+}
+
+int pyfcgi_logger_parse_field(const char** ptr, const char *start,
+                              pyfcgi_logger_fmt_field_t* cur_field,
+			      char fail_reason[PYFCGI_LOGGER_FMT_PARSE_ERRSZ])
+{
+	
+	const char *str_start, *field_start;
+	int ret;
+	char **name, **format;
+	size_t default_len;
+	pyfcgi_logger_field_type_e *type;
+	char *field_names[] = {"datetime", "level", "facility", "pid", "ident",
+	                       "msg", NULL};
+	pyfcgi_logger_field_type_e field_types[] = {
+		pyfcgi_logger_field_datetime, pyfcgi_logger_field_level,
+		pyfcgi_logger_field_facility, pyfcgi_logger_field_pid,
+		pyfcgi_logger_field_ident, pyfcgi_logger_field_msg};
+
+	str_start = *ptr;
+	field_start = *ptr;
+	name = field_names;
+	type = field_types;
+	while(*name)
+	{
+		if(**name != **ptr)
+		{
+			name++;
+			type++;
+			continue;
+		}
+		// Name found ?
+		while(**ptr && **name && **ptr != ':')
+		{
+			if(**ptr != **name)
+			{
+				break;
+			}
+			(*ptr)++;
+			(*name)++;
+		}
+		if(**ptr == ':' || **ptr == '}')
+		{
+			cur_field->type = *type;
+		}
+		else
+		{
+			snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
+				 "unknown field type '%s' chr %ld",
+				 str_start, str_start - start);
+			return 1;
+		}
+	}
+	(*ptr)++; //on field size or ':' or '}'
+	str_start = *ptr;
+	if(pyfcgi_logger_parse_field_sz(ptr, &(cur_field->len)))
+	{
+		snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
+			 "Unable to parse field size chr %ld '%s'",
+			 str_start - start, str_start);
+		return 1;
+	}
+	if(**ptr != ':' && **ptr != '}')
+	{
+		snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
+			 "Unable to parse field '%s' at chr %ld",
+			 field_start , *ptr - start);
+		return 1;
+	}
+	switch(cur_field->type)
+	{
+		case pyfcgi_logger_field_datetime:
+			default_len = 10;
+			cur_field->val = (void*)strftime;
+			format = &(cur_field->args.datetime.format);
+			ret = pyfcgi_logger_parse_field_dtfmt(ptr,format);
+			if(ret){
+				return ret;
+			}
+			break;
+		case pyfcgi_logger_field_level:
+			default_len = 7;
+			break;
+		case pyfcgi_logger_field_facility:
+			default_len = 6;
+			break;
+		case pyfcgi_logger_field_pid:
+			default_len = 5;
+			break;
+		case pyfcgi_logger_field_ident:
+			default_len = 0;
+			break;
+		case pyfcgi_logger_field_msg:
+			default_len = 0;
+			break;
+		default:
+			snprintf(fail_reason, PYFCGI_LOGGER_FMT_PARSE_ERRSZ,
+				 "Unknown error parsing field '%s' at chr %ld",
+				 field_start , *ptr - start);
+			return 1;
+	}
+	if(!cur_field->len && default_len)
+	{
+		cur_field->len = default_len;
+	}
+	return 0;
+}
+
+int pyfcgi_logger_parse_field_dtfmt(const char** ptr, char** format)
+{
+	const char *fmt;
+	size_t fmt_len;
+
+	fmt_len = 0;
+	fmt = *ptr;
+printf("FUCKOFF");
+	while(**ptr && **ptr != '}' && *((*ptr)+1) != '}')
+	{
+		ptr++;
+		fmt_len++;
+	}
+	if(!fmt_len)
+	{
+		fmt_len = sizeof(PYFCGI_LOGGER_TIME_FMT_DEFAULT);
+		fmt = PYFCGI_LOGGER_TIME_FMT_DEFAULT;
+	}
+	if(!(*format = strndup(fmt, fmt_len)))
+	{
+		pyfcgi_log(LOG_ALERT,
+		           "Unable to strdup field datetime format : %s",
+			   strerror(errno));
+		return PYFCGI_FATAL;
+	}
+	return 0;
+}
+
+int pyfcgi_logger_parse_field_sz(const char **ptr, size_t *size)
+{
+	char *end;
+	if(**ptr == '}' || **ptr == ':')
+	{
+		return (*size = 0);
+	}
+	if(**ptr < '0' && **ptr > 9)
+	{
+		return 1; // parse error
+	}
+	*size = strtoull(*ptr, &end, 10);
+	return 0;
+}
+
 int pyfcgi_logger_open(pyfcgi_logger_t *logger)
 {
 	if( (logger->fd = open(logger->filename,

src/pyworker.c

@@ -584,6 +584,7 @@ void update_python_path()
 			syslog(LOG_ALERT, "Unable to fetch python path, got NULL.");
 		}
 		err_fmt = NULL;
+		err = 0;
 		goto update_python_path_err_wcwd;
 	}
 	ppath = wcsdup(ppath);