ap/app/fota_upi_ab/src/main.c

/**
* @file main.c
* @brief fotaÉý¼¶Ö÷Èë¿Ú
*
* Copyright (C) 2017 Sanechips Technology Co., Ltd.
* @author
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/


/*******************************************************************************
 *                           Include header files                              *
 ******************************************************************************/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <dirent.h>
#include <getopt.h>
#include <unistd.h>

//#include "upi_log.h"
#include "zxic_fota_ab_upgrade.h"
//#include "upi_fotaflag_partition.h"

/*******************************************************************************
 *                             Macro definitions                               *
 ******************************************************************************/

#define POWER_WAKE_LOCK_FILE			("/sys/power/wake_lock")
#define POWER_WAKE_UNLOCK_FILE			("/sys/power/wake_unlock")
#define FOTA_UPGRADE_LOCK				("fota_upgrade_lock")

#define FOTA_UPI_VERIFY					("verify")
#define FOTA_UPI_UPDATE					("update")


/*******************************************************************************
 *                             Type definitions                                *
 ******************************************************************************/

typedef struct {
	int	option_value;
	int (*func)(char *);
} option_handle_t;



/*******************************************************************************
 *                       Static function declarations                          *
 ******************************************************************************/


static int excute_command_upgrade(char * option_para);
static int excute_command_get_current_system(char * option_para);
static int excute_command_set_boot_to_system(char * option_para);
static int excute_command_get_boot_to_system(char * option_para);
static int excute_command_get_status(char * option_para);
static int excute_command_get_system_info(char * option_para);
static int excute_command_set_system1_status(char * option_para);
static int excute_command_set_system2_status(char * option_para);
static int excute_command_get_fota_status(char * option_para);
static int excute_command_set_fota_status(char * option_para);
static int excute_command_help(char * option_para);
static int execute_command_version(char * option_para);
static int excute_command_init_fota_flag(char * option_para);
static int execute_command_sync(char *option_para);
static int execute_command_get_upgrade_type(char *option_para);
static int execute_command_get_sync_status(char * option_para);
static int execute_command_set_sync_status(char * option_para);



/*******************************************************************************
 *                       Global variable declarations                          *
 ******************************************************************************/

/*----------Command parser begin---------------------------------------------------------*/

static char * g_short_string = "u:cgb:sio:t:fqr:hvypne:";

static struct option g_long_options[] = {
	{"upgrade",				required_argument,	NULL,	'u'},
	{"get-current",			no_argument,		NULL,	'c'},
	{"get-boot",				no_argument,		NULL,	'g'},
	{"set-boot",				required_argument,	NULL,	'b'},
	{"get-upgrade_status",		no_argument,		NULL,	's'},
	{"get-system-info",		no_argument,		NULL,	'i'},
	{"set-system1-status",		required_argument,	NULL,	'o'},
	{"set-system2-status",		required_argument,	NULL,	't'},
	{"get-fota-status",     no_argument,       NULL, 'q'},
	{"set-fota-status",     required_argument, NULL, 'r'},	
	{"init-fota-flag",		no_argument,		NULL,	'f'},
	{"help",					no_argument,		NULL,	'h'},
	{"version",				no_argument,		NULL,	'v'},
	{"sync",				no_argument,			NULL,	'y'},			
	{"get-upgrade-type",	no_argument,			NULL,	'p'},
	{"get-sync-status",		no_argument,			NULL,	'n'},
	{"set-sync-status",		required_argument,		NULL,	'e'},
	{0, 0, 0, 0}
};

static option_handle_t g_option_handle[] = {
	{'u',		excute_command_upgrade},
	{'c',		excute_command_get_current_system},
	{'g',		excute_command_get_boot_to_system},
	{'b',		excute_command_set_boot_to_system},
	{'s',		excute_command_get_status},
	{'i',		excute_command_get_system_info},
	{'o',		excute_command_set_system1_status},
	{'t',		excute_command_set_system2_status},
	{'q',		excute_command_get_fota_status},
	{'r',		excute_command_set_fota_status},
	{'f',		excute_command_init_fota_flag},
	{'h',		excute_command_help},
	{'v',		execute_command_version},
	{'y',		execute_command_sync},
	{'p',		execute_command_get_upgrade_type},
	{'n',		execute_command_get_sync_status},
	{'e',		execute_command_set_sync_status}
};


/*----------Command parser end----------------------------------------------------------*/



/*******************************************************************************
 *                       Static function define                          *
 ******************************************************************************/




static void usage(void)
{
	printf("fota_upi  [-cgsiqhvypn] [-u <target>][-b <boot to system>][-otr <system info>][-e <sync status>]\n "
	        "  -u,  --upgrade               verify or update \n"
	        "  -c , --get-current           get current system \n"
	        "  -g , --get-boot              get boot to system \n"
	        "  -b,  --set-boot              set boot to system \n"
	        "  -s,  --get-status            get system status \n"
	        "  -i,  --get-system-info       get system info \n"
	        "  -o,  --set-system1-status    set system1 status info \n"
	        "  -t,  --set-system2-status    set system2 status info \n"
	        "  -q,  --get-fota-status       get fota status to show if need sync NV when next reboot, 0:no 1:yes \n"
	        "  -r,  --set-fota-status       set fota status to show if need sync NV when next reboot, 0:no 1:yes \n"
	        "  -f,  --init-fota-flag        init fota flag partition \n"
	        "  -h , --help                  show this usage text\n"
	        "  -v,  --version               show current version \n"
	        "  -y,  --sync               	sync \n"
	        "  -p,  --get-upgrade-type      get upgrade type \n"
	        "  -n,  --get-sync-status       get sync status \n"
	        "  -e,  --set-sync-status       set sync status \n");
}

z_upgrade_status_info_t g_upgrade_status;
void g_flush_upgrade_status(z_upgrade_status_info_t *p_status)
{
//	LOG_FUNC_BEGIN
	printf("Current status:%d \n", p_status->upgrade_status);

	printf("Total size:%d \n", p_status->total_size);

	printf("Updated size:%d \n", p_status->upgraded_size);
//	LOG_FUNC_END
}


/*----------Command parser function begin------------------------------------------------*/
static int excute_command_upgrade(char * option_para)
{
	int ret = -1;
	
	if (NULL == option_para) {
		usage();
		printf("Command input invalid! null input upgrade para, please choose verify or recovery or system! \n");
		return -1;
	}

	
	if (0 == strcmp(FOTA_UPI_VERIFY, option_para)) {
		printf("Begin to verify upgrade package \n");
		ret = zxic_dual_verify();
	} else if (0 == strcmp(FOTA_UPI_UPDATE, option_para)) {
//		ret = upi_update();
		z_upgrade_flush_status_t flush_status;
		z_upgrade_status_info_t status ;
		memset(&status, 0, sizeof(z_upgrade_status_info_t));
		flush_status.status = &status;
		flush_status.status_cb = &g_flush_upgrade_status;
		ret = zxic_dual_upgrade(&flush_status);
	} else {
		printf("Unknow input upgrade para, verify or  update! \n");
		return -1;
	}


	return ret;
}


static int excute_command_get_current_system(char * option_para)
{
	int current = zxic_dual_get_current_system();

	printf("Current system:0x%08X[%d] \n", current, current);

	return current;
}


static int excute_command_get_boot_to_system(char * option_para)
{
	int boot_to = zxic_dual_get_boot_to_system();

	printf("Boot to system:0x%08X[%d]\n", boot_to, boot_to);

	return 0;
}

static int excute_command_set_boot_to_system(char * option_para)
{
	int ret = 0;

	if (NULL == option_para) {
		usage();
		printf("Command input invalid value! null option parameters! \n");
		return -1;
	}

	ret = zxic_dual_set_boot_to_system(atoi(option_para), 0);
	if(ret < 0){
		printf("Set boot to [%s] error \n", option_para);
	}

	return ret;
}


static int excute_command_get_status(char *option_para)
{
	z_upgrade_status_info_t status;
	if(zxic_dual_get_upgrade_status(&status) < 0){
		printf("Get upgrade status fail! \n");
		return -1;
	}
	
	printf("Current upgrade info: \n");
	printf("Current upgrade status:%d \n", status.upgrade_status);
	printf("Current upgrade total size:%d \n", status.total_size);
	printf("Current upgrade updated size:%d \n", status.upgraded_size);
	
    return 0;
}

static int excute_command_get_system_info(char * option_para)

{
	z_upgrade_system_info_t system_info;
	if(zxic_dual_get_system_status(&system_info) < 0){
		printf("Get upgrade status fail! \n");
		return -1;
	}else{
		printf("System info: \n");
		printf("Boot to:0x%08X[%d] \n", system_info.boot_to, system_info.boot_to);
		printf("Fota status:%d \n", system_info.fota_status);
		printf("System1 system:0x%08X [%d] \n", system_info.system_1.system, system_info.system_1.system);
		printf("System1 status:%d \n", system_info.system_1.status);
		printf("System1 try_cnt:%d \n", system_info.system_1.try_cnt);
		printf("System2 system:0x%08X [%d] \n", system_info.system_2.system, system_info.system_2.system);
		printf("System2 status:%d \n", system_info.system_2.status);
		printf("System2 try_cnt:%d \n", system_info.system_2.try_cnt);
	}


	return 0;
}


static int excute_command_set_system1_status(char * option_para)
{
	int ret = -1;
	if (NULL == option_para) {
		usage();
		printf("Command input invalid value! null option parameters! \n");
		return -1;
	}
	
	ret = zxic_dual_set_system_status(34650, atoi(option_para));
	if(ret < 0){
		printf("Set system 1 status to [%s] error \n", option_para);
	}	

	return ret;
}

static int excute_command_set_system2_status(char * option_para)
{
	int ret = -1;
	if (NULL == option_para) {
		usage();
		printf("Command input invalid value! null option parameters! \n");
		return -1;
	}
	
	ret = zxic_dual_set_system_status(39019, atoi(option_para));
	if(ret < 0){
		printf("Set system 2 status to [%s] error \n", option_para);
	}	

	return ret;
}

static int excute_command_get_fota_status(char * option_para)
{
	int status = zxic_dual_get_fota_status_for_nv();

	printf("Fota status:%d \n", status);

	return 0;
}

static int excute_command_set_fota_status(char * option_para)
{
	int ret = 0;

	if (NULL == option_para) {
		usage();
		printf("Command input invalid value! null option parameters! \n");
		return -1;
	}

	ret = zxic_dual_set_fota_status_for_nv(atoi(option_para));
	if(ret < 0){
		printf("Set fota_status to [%s] error \n", option_para);
	}

	return ret;
}

static int excute_command_init_fota_flag(char * option_para)
{
	int ret = 0;

	if(zxic_init_flag_partition() < 0){
		printf("Init fotaflag partition fail! \n");
		return -1;
	}


	return 0;
}





static int excute_command_help(char * option_para)
{
	usage();
	return 0;
}





static int execute_command_version(char *option_para)
{
	int version = 0;


	return version;
}





static int execute_command_sync(char *option_para)
{
	int ret = -1;

	ret = zxic_dual_sync_system();

	return ret;
}





static int execute_command_get_upgrade_type(char *option_para)
{
	int upgrade_type = -1;
	
	upgrade_type = zxic_dual_get_upgrade_type();
	printf("upgrade type is %d\n", upgrade_type);

	return 0;
}


static int execute_command_get_sync_status(char * option_para)
{
	int sync_status = -2;
	
	zxic_dual_get_sync_status(&sync_status);
	printf("Current sync status is %d\n", sync_status);

	return 0;
}


static int execute_command_set_sync_status(char * option_para)
{
	int ret = -1;
	
	if (NULL == option_para) {
		usage();
		printf("Command input invalid value! null option parameters! \n");
	
		return ret;
	}
	
	ret = zxic_dual_set_sync_status(atoi(option_para));
	if (0 != ret)
	{
		printf("set sync status fail\n");
		
		return ret;
	}
	
	ret = 0;
	
	return ret;
}


/*----------Command parser function end---------------------------------------------------*/


/**
 * @brief		дËøÎļþ
 * @param	filepath:	Îļþ·¾¶
 * @param	setbuf:	дÈëÄÚÈÝ
 * @return	NA
 * @retval
 * @note
 */
static void write_lockfile(char *filepath, char *setbuf)
{
	int f, len = 0;

	f = open(filepath, O_RDWR | O_SYNC);
	if (f == -1) {
		perror("open lock  failed\n");
		return;
	}

	len = strlen(setbuf);

	if (write(f, setbuf, len) != len) {
		perror("write  lock failed\n");
	}

	close(f);
}

/*******************************************************************************
 *                       Global function declarations                          *
 ******************************************************************************/

int main(int argc, char *argv[])
{
	int i				= 0;
	int option_index	= 0;
	int cmd_num		= 0;

	int ret			= -1;
	int ch			= -1;

    printf("build date: %s %s\n", __DATE__, __TIME__);

	
	write_lockfile(POWER_WAKE_LOCK_FILE, FOTA_UPGRADE_LOCK);

	while ((ch = getopt_long(argc, argv, g_short_string, g_long_options, &option_index)) != -1) {
		for (i = 0; i < sizeof(g_option_handle) / sizeof(option_handle_t); i++) {
			if (ch != g_option_handle[i].option_value)
				continue;


			cmd_num++;

			if (NULL == g_option_handle[i].func) {
				printf("Command short string is:%c, but option handle func is NULL", ch);
				break;
			}

			ret = g_option_handle[i].func(optarg);

			if (ret < 0) {
				ret = -1;
				goto end;
			}
		}
	}

	if (0 == cmd_num) {
		printf("Can not find valid command!");
		usage();
		ret = -1;
		goto end;
	}

	ret = 0;

end:

	write_lockfile(POWER_WAKE_UNLOCK_FILE, FOTA_UPGRADE_LOCK);

	return ret ;

}