ap/app/zte_log_agent/log_agent_sdcard.c

/**
 * 
 * @file      log_agent_sdcard.c
 * @brief     
 *            This file is part of ZCAT.
 *            zcatÓ¦Óòãlog_agent´¦Àíͨ¹ýsd¿¨µÄÊý¾ÝÁ÷
 *            
 * @details   
 * @author    Tools Team.
 * @email     
 * @copyright Copyright (C) 2013 Sanechips Technology Co., Ltd.
 * @warning   
 * @date      2019/02/02
 * @version   1.2
 * @pre       
 * @post      
 *            
 * @par       
 * Change History :
 * ---------------------------------------------------------------------------
 * date        version  author         description
 * ---------------------------------------------------------------------------
 * 2017/07/17  1.0      hou.bing       Create file
 * 2019/01/24  1.1      jiang.fenglin  1.Ìí¼Óusblog¶ÁдËø
 *                                     2.Ìí¼ÓÏß³ÌÃû³Æ
 * 2019/02/02  1.2      jiang.fenglin  ÐÞ¸Ä×¢ÊÍ·½Ê½Îªdoxygen
 * 2019/07/08  1.3      jiang.fenglin  Ôö¼ÓAPFS/CPFSģʽ
 * ---------------------------------------------------------------------------
 * 
 * 
 */

#include <string.h>
#include <pthread.h>
#include <sys/prctl.h>
#include <sys/statfs.h>
#include "log_agent.h"
#include "cfg_api.h"

#if 0
#define DEFAULT_LOG_ROOT "/sdcard"
#define DEFAULT_LOG_ROOT_PARENT "/ZTELog"
#define CONFIG_STORAGE_FILE_PATH "/data/misc/rild/log_storage.cfg"
#endif

#define USB_DEV_SDCARD_PATH      "/dev/mmcblk0p1"
#define USB_DEV_SDCARD_PATH_BACK "/dev/mmcblk0"

#define ZCAT_SDCARD_MOUNT_PATH   "/tmp/udisk"

#define ZCAT_SDCARD_RULE_PATH    "/tmp/udisk/log.rule"
#define ZCAT_SDCARD_LOG_PATH     "/tmp/udisk/zcat_log"

#define ZCAT_FS_RULE_PATH        "/var/zcat/log.rule"
#define ZCAT_FS_PATH             "/var/zcat"


static T_LOG_SDCARD_PARA g_log_sdcard_para = { {0} };
pthread_t rule_heartbeat_thread = 0;

extern int deal_with_encoded_data(unsigned char *buffer,int buf_len);

typedef struct
{
    char head1[16];
    int heartbeat_pos;
    int heartbeat_len;
    int rule_pos;
    int rule_len;
    int ap_rule_pos;
    int ap_rule_len;
	int log_file_size;
	int log_file_cnt;
}rule_struct;

char g_heartbeat_buff[35] = {
    0x01,0xaa,0xaa,0xaa,0x01,0x55,0x73,0x01,
    0x14,0x00,0x00,0x00,0x06,0x01,0xbb,0xbb,
    0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
    0xe6,0x7a,0x7e
};

/* É豸¾ä±ú */
extern BOOL bSDSet;
extern int cplog_fd;


/**
 * @brief ÅжÏĿ¼ÊÇ·ñ´æÔÚ£¬Èç¹û²»´æÔÚÔò´´½¨Ò»¸öеÄĿ¼
 * @param[in] dir_path Ŀ¼·¾¶
 * @return 0 on success, -1 error.
 * @note
 * @see 
 */
int test_dir_exist(char* dir_path)
{
    DIR *p_dir = NULL;
    
    if ((p_dir = opendir(dir_path)) == NULL)
    {
        printf("[zcat] opendir failed, mkdir %s\n", dir_path);
        if (mkdir(dir_path, 0777) != 0)
        {
            printf("[zcat] mkdir %s error, error info: %s\n", dir_path, strerror(errno));
            return -1;
        }
    }
    else
    {
        closedir(p_dir);
        p_dir = NULL;
    }
    return 0;
}

/**
 * @brief ³õʼ»¯sd¿¨´ælogµÄÅäÖòÎÊý
 * @return void
 * @note
 * @see 
 */
static void init_sdcard_para()
{
    g_log_sdcard_para.max_file_size = 1024 * 1024 * 100;
    //g_log_sdcard_para.max_file_num = 8;
    g_log_sdcard_para.log_overwrite = 1;
    g_log_sdcard_para.compress_log_files = 1;
    g_log_sdcard_para.file_counts = 0;
    g_log_sdcard_para.output_fd = -1;
	g_log_sdcard_para.free_space_limit = 1024 * 1024 * 1;

	memset(g_log_sdcard_para.rule_path, 0, sizeof(g_log_sdcard_para.rule_path));
	strcpy(g_log_sdcard_para.rule_path, ZCAT_SDCARD_RULE_PATH);
}

/**
 * @brief ³õʼ»¯sd¿¨normalģʽ²ÎÊý
 * @return void
 * @note
 * @see 
 */
static int init_sdcard_flash_mode()
{
	memset(g_log_sdcard_para.log_dir, 0, sizeof(g_log_sdcard_para.log_dir));
    strcpy(g_log_sdcard_para.log_dir, ZCAT_SDCARD_LOG_PATH);

    if(test_dir_exist(g_log_sdcard_para.log_dir) < 0)//´´½¨ÈÕÖ¾Îļþ¼Ð
    {
        printf("[zcat] test %s dir exist failed. \n", g_log_sdcard_para.log_dir);
        return -1;
    }
    return 0;
}

/**
 * @brief ³õʼ»¯sd¿¨uÅÌģʽ²ÎÊý
 * @return void
 * @note
 * @see 
 */
static int init_sdcard_u_mode()
{
	memset(g_log_sdcard_para.log_dir, 0, sizeof(g_log_sdcard_para.log_dir));
    strcpy(g_log_sdcard_para.log_dir, ZCAT_SDCARD_LOG_PATH);
    if(test_dir_exist(ZCAT_SDCARD_LOG_PATH) < 0)//ÅжÏËùÓÐÈÕ־Ŀ¼ÊÇ·ñ´æÔÚ
    {
        printf("[zcat] test_dir_exist failed:%s. \n", ZCAT_SDCARD_LOG_PATH);
        return -1;
    }
    /*if(test_dir_exist(MODEM_LOG_PATH) < 0)//ÅжÏcpÈÕ־Ŀ¼ÊÇ·ñ´æÔÚ
    {
        printf("test_dir_exist failed:%s. \n", MODEM_LOG_PATH);
        return -1;
    }*/
    return 0;
}

int zCat_MountSd()
{    
    char cmd[100] = { 0 };
    
    if(test_dir_exist(ZCAT_SDCARD_MOUNT_PATH) < 0) // ´´½¨¹ÒÔصÄÁÙʱÎļþ¼Ð
    {
        printf("[zcat] create %s fail.\n", ZCAT_SDCARD_MOUNT_PATH);
        return -1;
    }

    printf("[zcat] init sd output dir successs.\n");

    memset(cmd, 0, sizeof(cmd));
    sprintf(cmd, "mount -t vfat %s %s", USB_DEV_SDCARD_PATH, ZCAT_SDCARD_MOUNT_PATH); 
    if(0 != zxic_system(cmd))
    {
        printf("[zcat] cmd %s fail!\n", cmd);

        memset(cmd, 0, sizeof(cmd));
        sprintf(cmd, "mount -t vfat %s %s", USB_DEV_SDCARD_PATH_BACK, ZCAT_SDCARD_MOUNT_PATH); 
        if(0 != system(cmd))
        {
            printf("[zcat] cmd %s fail, mount error!\n", cmd);
            return -1;
        }
    }
    
    return 0;
}

/**
 * @brief ɾ³ýĿ¼ÏÂÔçÆÚ´´½¨µÄÎļþ\n
 *        ¸ù¾ÝÎļþÃûÅжϴ´½¨Ê±¼ä£¬É¾³ý×îÏÈ´´½¨µÄÄǸöÎļþ
 * @param[in] dir_path ÎÄĿ¼·¾¶
 * @return void
 * @note
 * @see 
 */
static void delete_oldest_file(char* dir_path)
{
    DIR *p_dir = NULL;
    struct dirent *p_entry = NULL;
    char oldest_file[64] = "99999999999999";    //ÈÕÆÚµÄ×î´óÖµ
    char file_name[MAX_STRING_LENGTH] = {0};
    p_dir = opendir(dir_path);

    if(p_dir)
    {
	    while ((p_entry = readdir(p_dir)) != NULL)
	    {
	        if (strncmp(p_entry->d_name, ".", 1) == 0)
	            continue;

	        if (strcmp(p_entry->d_name, oldest_file) < 0)
	        {
	            strncpy(oldest_file, p_entry->d_name, 64 - 1);
	        }
	    }

	    snprintf(file_name, MAX_STRING_LENGTH, "%s/%s", dir_path, oldest_file);
	    if(remove(file_name) != 0)
	    {
	        printf("[zcat] remove %s fail!errno=%d(%s)\n",file_name,errno,strerror(errno));
	    }
	    closedir(p_dir);
    }
}


/**
 * @brief ÔÚdir_pathĿ¼Ï´ò¿ªlogÊä³öÎļþ²¢·µ»ØÎļþ¾ä±ú,\n
 *        ÒÔµ±Ç°Ê±¼äΪÎļþÃû£¬´´½¨logÊä³öÎļþ¡£logÎļþ×î´óÊýÁ¿ÓÉLOG_FILE_MAX_NO¾ö¶¨£¬
 *        Èôµ±Ç°ÎļþÊýÒÑ´ïÉÏÏÞ£¬É¾³ý×îÏÈ´´½¨µÄÎļþ,ÔÙÒÔµ±Ç°Ê±¼äΪÎļþÃû´´½¨Îļþ
 * @param[in] log_sdcard_para ÈÕÖ¾´æT¿¨²ÎÊý
 * @return ´ò¿ªµÄlogÎļþÃèÊö·û
 * @note
 * @see 
 */
static int open_log_file(T_LOG_SDCARD_PARA* log_sdcard_para)
{
    int fd = -1;
    char file_name[MAX_STRING_LENGTH] = {0};
    struct tm *cur_time;
    time_t now;

    now = time(NULL);
    cur_time = localtime(&now);

	if(cur_time != NULL)
		snprintf(file_name, MAX_STRING_LENGTH, "%s/%d_%02d%02d_%02d%02d%02d%s", log_sdcard_para->log_dir, cur_time->tm_year + 1900,
             cur_time->tm_mon + 1, cur_time->tm_mday, cur_time->tm_hour, cur_time->tm_min,
             cur_time->tm_sec, ".log");

    if (log_sdcard_para->log_overwrite)
    {
        log_sdcard_para->file_counts++;

		struct statfs diskInfo;
		statfs(g_log_sdcard_para.log_dir, &diskInfo);

		if (diskInfo.f_bfree * diskInfo.f_bsize < log_sdcard_para->free_space_limit)
        //if (log_sdcard_para->file_counts > log_sdcard_para->max_file_num)
        {
            delete_oldest_file(log_sdcard_para->log_dir);
            log_sdcard_para->file_counts--;
        }
    }

    fd = open(file_name, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH);

    if (fd >= 0)
    {
        fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP |S_IWGRP | S_IROTH |S_IWOTH);
    }
    strncpy(log_sdcard_para->log_name, file_name, MAX_STRING_LENGTH-1);

    return fd;
}

/**
 * @brief ³õʼ»¯logµÄĿ¼
 * @param[in] n/a
 * @return 0 on success, errno otherwise
 * @note
 * @see 
 */
int init_fs_log_dir()
{
	struct statfs diskInfo;

	(void)(diskInfo);
	
    g_log_sdcard_para.max_file_size = 1024 * 1024 * 10;
    //g_log_sdcard_para.max_file_num = 5;
    g_log_sdcard_para.log_overwrite = 1;
    g_log_sdcard_para.compress_log_files = 1;
    g_log_sdcard_para.file_counts = 0;
    g_log_sdcard_para.output_fd = -1;
	g_log_sdcard_para.free_space_limit = 1024 * 1024 * 1;

	memset(g_log_sdcard_para.rule_path, 0, sizeof(g_log_sdcard_para.rule_path));
	strcpy(g_log_sdcard_para.rule_path, ZCAT_FS_RULE_PATH);
	
	memset(g_log_sdcard_para.log_dir, 0, sizeof(g_log_sdcard_para.log_dir));
    strcpy(g_log_sdcard_para.log_dir, ZCAT_FS_PATH);

    if(test_dir_exist(g_log_sdcard_para.log_dir) < 0)//´´½¨ÈÕÖ¾Îļþ¼Ð
    {
        printf("[zcat] test %s dir exist failed. \n", g_log_sdcard_para.log_dir);
        return -1;
    }

    g_log_sdcard_para.output_fd = open_log_file(&g_log_sdcard_para);//´ò¿ªÈÕÖ¾Îļþ
    if (g_log_sdcard_para.output_fd == -1)
    {
        printf("[zcat] failed to open log file!\n");
        return -1;
    }
    return 0;
}

/**
 * @brief ³õʼ»¯sd¿¨´ælogµÄĿ¼
 * @param[in] mode normalģʽ/uÅÌģʽ
 * @return 0 on success, errno otherwise
 * @note
 * @see 
 */
int init_sdcard_log_dir(E_FLASH_MODE mode)
{   
    init_sdcard_para();
    
    if(mode == FLASH_MODE_U)
    {       
        if(init_sdcard_u_mode() < 0)
        {
            printf("[zcat] init_sdcard_u_mode failed!\n");
            return -1;
        }
    }
    else
    {
        if(init_sdcard_flash_mode() < 0)
        {
            printf("[zcat] init_sdcard_flash_mode failed!\n");
            return -1;
        }
    }

    g_log_sdcard_para.output_fd = open_log_file(&g_log_sdcard_para);//´ò¿ªÈÕÖ¾Îļþ
    if (g_log_sdcard_para.output_fd == -1)
    {
        printf("[zcat] failed to open log file!\n");
        return -1;
    }
    return 0;
}

/**
 * @brief дlogµ½SD¿¨.\n
 * @param[in] fd ÉÏÒ»´ÎдÈësd¿¨ÖеÄzlfÎļþÃèÊö·û
 * @param[in] buf ´ýдÈëµÄÊý¾ÝÖ¸Õë
 * @param[in] len ´ýдÈëµÄÊý¾ÝÖ¸³¤¶È
 * @param[in] log_sdcard_para sd¿¨²ÎÊý
 * @return ʵ¼ÊдÈëµÄ³¤¶È
 * @note
 * @see 
 */
static int output_log_to_sdcard(int fd, unsigned char *buf, int len, T_LOG_SDCARD_PARA* log_sdcard_para)
{
    int output_fd = fd;
    int write_len = 0;

    //static int file_size = 0;
    log_sdcard_para->file_size += len;

    // Èç¹ûÎļþ´óС´ïµ½×î´óÎļþ³ß´ç£¬Ôòн¨Ò»¸öÎļþ
    if (log_sdcard_para->file_size > log_sdcard_para->max_file_size)
    {
        close(fd);

        if (log_sdcard_para->compress_log_files)
        {
            //compress_log_files(g_log_dir);
        }

        output_fd = open_log_file(log_sdcard_para);
        if (output_fd == -1)
        {
            return -1;
        }
        log_sdcard_para->output_fd = output_fd;
        log_sdcard_para->file_size = len;
    }

    write_len = write(output_fd, buf, len);
    if(write_len != len) // Èç¹ûT¿¨Ð´Âú£¬Ôòɾ³ý֮ǰµÄlogÎļþ
    {
        delete_oldest_file(log_sdcard_para->log_dir);
        log_sdcard_para->file_counts--;
        write_len = write(output_fd, buf, len);
        if(write_len != len)
        {
            return -1;
        }
    }

    return write_len;
}

/**
 * @brief bufferÄÚÈÝдÈëµ½T¿¨
 * @param[in] buffer ´ýдÈëÊý¾ÝÖ¸Õë
 * @param[in] buffer_len ´ýдÈëÊý¾Ý³¤¶È
 * @return ʵ¼ÊдÈëµÄ³¤¶È
 * @note
 * @see 
 */
int send_message_to_sdcard(unsigned char* buf, int len)
{
    return output_log_to_sdcard(g_log_sdcard_para.output_fd, buf, len, &g_log_sdcard_para);
}

/**
 * @brief ·¢Ë͹æÔòÎļþµ½cp.\n
 * @param[in] fd ¹æÔòÎļþÃèÊö·û
 * @param[in] offset ÎļþÆ«ÒÆ
 * @param[in] length ·¢ËÍÊý¾Ý³¤¶È
 * @return 0 on success, -1 otherwise
 * @note
 * @see 
 */
static int send_rules_to_cp(int fd, int offset, int length)
{
    char buf[1024] = {0};
    int left_len = 0;
    int next_buf_len = 0;
    int read_len = 0;
    
    if(lseek(fd, offset, SEEK_SET) == -1)
    {
        printf("[zcat] rules file lseek to pos %d failed (%s)\n", offset, strerror(errno));
        return -1; 
    }
    
    left_len = length;
    next_buf_len = sizeof(buf) < left_len ? sizeof(buf) : left_len;
    while((read_len = read(fd, buf, next_buf_len)) > 0)
    {
        int write_len = write(cplog_fd, buf, read_len);
        if (write_len != read_len)
        {
            printf("[zcat] send_rule error, write_len = %d, len = %d.\n", write_len, read_len);
            return -1;
        }
        left_len -= read_len;
        next_buf_len = sizeof(buf) < left_len ? sizeof(buf) : left_len;
    }
    return 0;
}


/**
 * @brief ·¢Ë͹æÔòÎļþµ½ap, app devºÍkernel dev.\n
 * @param[in] fd ¹æÔòÎļþÃèÊö·û
 * @param[in] offset ÎļþÆ«ÒÆ
 * @param[in] length ·¢ËÍÊý¾Ý³¤¶È
 * @return 0 on success, -1 otherwise
 * @note
 * @see 
 */
static int send_rules_to_ap(int fd, int offset, int length)
{
    unsigned char buf[1024] = {0};
    int left_len = 0;
    int next_buf_len = 0;
    int read_len = 0;
    
    if(lseek(fd, offset, SEEK_SET) == -1)
    {
        printf("[zcat] rules file lseek to pos %d failed (%s)\n", offset, strerror(errno));
        return -1; 
    }
    
    left_len = length;
    next_buf_len = sizeof(buf) < left_len ? sizeof(buf) : left_len;
    while((read_len = read(fd, buf, next_buf_len)) > 0)
    {
        deal_with_encoded_data(buf, read_len);
        next_buf_len = sizeof(buf) < left_len ? sizeof(buf) : left_len;
    }
    return 0;
}

/**
 * @brief ¼ì¹æÔòÎļþºÏ·¨ÐÔ£¬¶ÁÈ¡ÕªÒªÐÅÏ¢.\n
 * @param[in] fd ¹æÔòÎļþÃèÊö·û
 * @param[out] rule_info ¹æÔòÎļþ¸ÅÒªÐÅÏ¢
 * @return ¹æÔòÎļþµÄ´óС
 * @note
 * @see 
 */
static int get_rule(int fd, rule_struct *rule_info)
{
    int len = 0;
    
    len = read(fd, rule_info, sizeof(rule_struct));
    if(len <= 0)
    {
        printf("[zcat] rule file len = %d\n", len);
        return len;
    }
    printf("[zcat] rule_info\n\theartbeat_pos : %d\n\theartbeat_len : %d\n\trule_pos      : %d\n\trule_len      : %d\n",
        rule_info->heartbeat_pos,
        rule_info->heartbeat_len,
        rule_info->rule_pos,
        rule_info->rule_len
        );

    if(rule_info->heartbeat_len > sizeof(g_heartbeat_buff))
    {
        printf("[zcat] check_rule, heartbeat voerload %d error.\n", sizeof(g_heartbeat_buff));
        return -1;
    }

    // ¶ÁÈ¡¹æÔòÎļþÖеÄÐÄÌø°üÊý¾Ý£¬Ì滻ĬÈÏÐÄÌøÊý¾Ý
    if(lseek(fd, rule_info->heartbeat_pos, SEEK_SET) == -1)
    {
        printf("[zcat] check_rule, lseek to heartbeat_pos error.\n");
        return -1;
    }
    if(read(fd, g_heartbeat_buff, rule_info->heartbeat_len) <= 0)
    {
        printf("[zcat] check_rule, read heartbeat data error.\n");
        return -1;
    }
    
    return len;
}

/**
 * @brief ¹æÔòºÍÐÄÌø·¢ËÍỊ̈߳¬\n
 *        ¶ÁÈ¡sd¿¨ÖеĹæÔòÎļþ·¢Ë͸øpc£¬ÖÜÆÚÐԵķ¢ËÍÐÄÌø.
 * @param[in] arg sd¿¨ÎļþÃèÊö·û
 * @return void
 * @note
 * @see 
 */
static void rule_heartbeat_entry(void *arg)
{
    BOOL bSendRule = FALSE;
    int rule_file_fd = 0;
    int rule_len = 0;
    rule_struct rule_info = { {0} };
    char* heartbeat_buf = g_heartbeat_buff;
    int heartbeat_len = sizeof(g_heartbeat_buff);

    prctl(PR_SET_NAME, "heartbeat");
    
    while(TRUE)
    {
        int write_len = write(cplog_fd, heartbeat_buf, heartbeat_len);
        if (write_len != heartbeat_len)
        {
            printf("[zcat] send heartbeat failed! %d, %d, %d\n", cplog_fd, heartbeat_len, write_len);
        }
        
        sleep(2);
        if(bSDSet == TRUE && bSendRule == FALSE)
        {
             rule_file_fd = open(g_log_sdcard_para.rule_path, O_RDONLY, S_IRUSR);
             if (rule_file_fd < 0)
             {
                printf("[zcat] failed to open rule file %s.\n", g_log_sdcard_para.rule_path);
                return;
             }

             // ¼ì²é¹æÔòÎļþºÏ·¨ÐÔ
             rule_len = get_rule(rule_file_fd, &rule_info);
             if(rule_len <= 0)
             {
				close(rule_file_fd);
				return;
             }
             printf("[zcat] check rule success,len is %d\n", rule_len);

             // ·¢ËÍcp¹æÔò
             send_rules_to_cp(rule_file_fd, rule_info.rule_pos, rule_info.rule_len);
             printf("[zcat] send rules to cp %d bytes,position %d\n",
                rule_info.rule_len,
                rule_info.rule_pos);
             // ·¢ËÍap¹æÔò
             send_rules_to_cp(rule_file_fd, rule_info.ap_rule_pos, rule_info.ap_rule_len);
             printf("[zcat] send rules to cp %d bytes,position %d\n", 
                rule_info.ap_rule_len,
                rule_info.ap_rule_pos);
             
             close(rule_file_fd);
             bSendRule = TRUE;
        }
    }
}

#if 0
/**
 * @brief »ñÈ¡sdcardģʽ
 * @param[in] void
 * @return sdcardģʽ
 * @note
 * @see 
 */
static E_FLASH_MODE get_flash_mode()
{
    E_FLASH_MODE flash_mode = FLASH_MODE_NOMAL;

    return flash_mode;
}
#endif

/**
 * @brief ³õʼ»¯sdcardģʽ£¬´´½¨¹æÔòºÍÐÄÌø·¢ËÍÏß³Ì.
 * @param[in] void
 * @return 0 on success, errno otherwise
 * @note
 * @see 
 */
int init_sdcard_mode()
{
    //E_FLASH_MODE flash_mode = FLASH_MODE_NOMAL;
    
    //flash_mode = get_flash_mode();
    pthread_create(&rule_heartbeat_thread, NULL, (void*)rule_heartbeat_entry, NULL);
    
    return 0;
}