mesa-framework-mesa-handle-logger/src/MESA_handle_logger.c

#include "MESA_handle_logger.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include<sys/stat.h>

typedef struct log_handle_t
{
    int runtime_log_level;
    char runtime_log_file[1200];
} log_handle_t;

#define THREAD_CTIME(t, buf, len)       thread_safe_ctime(t, buf, len)
#define LOGMSG_MAX_LEN      4096

const int HANDLE_LOGGER_VERSION_20170816 = 1;

char *thread_safe_ctime(const time_t *tp, char *buf, int len)
{
    unsigned int year, month, day, weekday, hour, min, sec;
    unsigned int year_days = 365;
    unsigned int month_days[12] =
    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    static unsigned char weekday_str[7][4] =
    {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
    static unsigned char month_str[12][4] = {"Jan", "Feb", "Mar", "Apr",
                                             "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
                                            };
    sec = * tp;
    min = sec / 60; sec = sec % 60;
    hour = min / 60; min = min % 60; hour += 8;
    day = hour / 24; hour = hour % 24;
    weekday = day % 7; weekday = (weekday + 4) % 7;

    for(year = 1970; day >= year_days;)
    {
        day -= year_days;
        year ++;

        if(0 == year % 4 && (0 != year % 100 || 0 == year % 400))
            year_days = 366;
        else year_days = 365;
    }

    if(366 == year_days) month_days[1] = 29;

	//bug fix by yw 20120808
    for(month = 0; day >= month_days[month];)
    {
        day -= month_days[month];
        month ++;
    }

    /*
    snprintf(buf, len, "%02d:%02d:%02d, %04d/%02d/%02d, %s",
        hour, min, sec, year, month, day, weekday_str[week_day]);
    */
    snprintf(buf, len, "%s %s %d %02d:%02d:%02d %d", weekday_str[weekday],
             month_str[month], day + 1, hour, min, sec, year);
    return buf;
}

static int create_dir(const char *dir_path, int path_len)
{
    if(dir_path == NULL)
        return -1;

    char *buf = (char *)calloc(path_len+1, 1);
    int ret = -1;

    memcpy(buf, dir_path, path_len);
    if(access(buf, R_OK) != 0)
    {
        if(mkdir(buf, 0755)!= 0)
            ret = -1;
        else
            ret =  0;
    }
    else
        ret =  1;
    free(buf);
    buf = NULL;
    return ret;
}

static int create_path(const char *path, int path_len)
{
    const char *p_cur = path;
    int i = 0;

    if(create_dir(path, path_len) >= 0)
        return 0;

    for(;i<=path_len;i++,p_cur++)
    {
        if(*p_cur == '/')
        {
            if(create_dir(path, i+1) < 0)
                return -1;
        }
    }
    return 0;
}

void *MESA_create_runtime_log_handle(const char *file_path, int level)
{
	if(file_path == NULL)
		return NULL;

    FILE *fp  = NULL;
    log_handle_t *p_handle = NULL;

    //creating file_path failed, return NULL
	char *p_path = rindex(file_path, '/');
	if(p_path != 0)
	{
		if(create_path(file_path, p_path - file_path) < 0)
			return NULL;
	}
    if(NULL == (fp = fopen(file_path, "w")))
		return NULL;

    fclose(fp);
    //remove(file_path);
    p_handle = (log_handle_t *)calloc(sizeof(log_handle_t), 1);

    if(p_handle == NULL)
		return NULL;

    strncpy(p_handle->runtime_log_file, file_path, 1024);
    p_handle->runtime_log_file[1024] = '\0';
    p_handle->runtime_log_level = level;
    return (void *)p_handle;
}

void MESA_destroy_runtime_log_handle(void *handle)
{
    if(handle != NULL)
    {
        free(handle);
        handle = NULL;
    }

    return;
}

void MESA_handle_runtime_log(void *handle, int level, const char *module, const char *fmt, ...)
{
    char buf[LOGMSG_MAX_LEN + 1];
    time_t t;
    int len;
    va_list ap;
    FILE *fp;
    struct tm local_time;
    char tmp_log_file_name[1201];
    log_handle_t *p_handle = (log_handle_t *)handle;

    if(p_handle == NULL || p_handle->runtime_log_file == NULL)return;

    if(level < p_handle->runtime_log_level) return;

    time(&t);
    THREAD_CTIME(&t, buf, LOGMSG_MAX_LEN);
    len = strlen(buf);

    switch(level)
    {
        case RLOG_LV_DEBUG:
            len += snprintf(buf + len,
                            LOGMSG_MAX_LEN - len, ", %s, ", "DEBUG");
            break;

        case RLOG_LV_INFO:
            len += snprintf(buf + len,
                            LOGMSG_MAX_LEN - len, ", %s, ", "INFO");
            break;

        case RLOG_LV_FATAL:
            len += snprintf(buf + len,
                            LOGMSG_MAX_LEN - len, ", %s, ", "FATAL");
            break;

        default:
            len += snprintf(buf + len,
                            LOGMSG_MAX_LEN - len, ", %s, ", "UNKNOWN");
            break;
    }

    if(0 >= LOGMSG_MAX_LEN - len) return;

    len += snprintf(buf + len, LOGMSG_MAX_LEN - len, "%s, ", module);

    if(0 >= LOGMSG_MAX_LEN - len) return;

    va_start(ap, fmt);
    len += vsnprintf(buf + len, LOGMSG_MAX_LEN - len, fmt, ap);
    va_end(ap);

    if(0 >= LOGMSG_MAX_LEN - len) return;

    len += snprintf(buf + len, LOGMSG_MAX_LEN - len, "\n");

    if(NULL == (localtime_r(&t, &local_time))) return;

    sprintf(tmp_log_file_name, "%s.%04d-%02d-%02d", p_handle->runtime_log_file,
            local_time.tm_year + 1900, local_time.tm_mon + 1,
            local_time.tm_mday);

    if(NULL == (fp = fopen(tmp_log_file_name, "a"))) return;

    fprintf(fp, "%s", buf);
    fclose(fp);
}