bt-67xx_universal_hw/modules/cli/CLI_Commands.c

/*
 * CLI_Commands.c
 *
 *  Created on: 28.11.2017
 *      Author: balbekova
 */

/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"

/* Standard includes. */
#include <stdint.h>
#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif
#include <string.h>
#include <stdlib.h>

/* FreeRTOS+CLI includes. */
#include "FreeRTOS_CLI.h"

#include "snmp_api.h"
#include "trap_api.h"
#include "sntp_api.h"
#include "lwip/ip_addr.h"
#include "settings_api.h"
#include "log.h"
#include "megatec.h"
#include "web_params_api.h"
#include "hal.h"
#include "parameters.h"
#include "CLI_Commands.h"
#include "CLI_Parameters.h"
#include "cli.h"
#include "netconf.h"
#include "control_symbol.h"
#include "syslog.h"

const int8_t *const pcInvalidCommand = ( int8_t * )
    "Неправильно введены параметры команды.  Введите \"help\" для просмотра списка поддерживаемых команд.\r\n\r\n";
const int8_t *const pcPermissionDenied = ( int8_t * ) "Отказ в доступе!\r\n\r\n";
const int8_t *const pcSystymeDenied = ( int8_t * )
    "Ручной ввод времени не доступен!\r\n\r\n";


const char *info_args_list[] = {
    "name",
    "address",
    "owner",
    "comments",
};

const char *ups_args_list[] = {
    "battest",
    "shutdown",
};

const char *systime_args_list[] = {
    "date",
    "time",
};

const char *network_args_list[] = {
    "info",
    "dhcp",
    "ip",
    "gw",
    "mask",
};

const char *snmp_args_list[] = {
    "info",
    "server",
    "community",
};

const char *akb_args_list[] = {
    "info",
    "voltcellmin",
    "voltcellmax",
#if HARDWARE_BT6709 || HARDWARE_BT6709_MTS
    "capacity",
    "voltakb",
    "lifetime",
    "dataset",
    "upspower",
#else if HARDWARE_BT6711
    "capacity",
    "voltakb",
    "upspower",
#endif
};

const char *type_alarm_args_list[] = {
    "info",
    "temp",
    "load",
    "vout",
#ifdef VAC_IN_MONITOR
    "vacin",
#endif
};

const char *alarm_args_list[] = {
    "low",
    "high",
    "hist",
};

const char *notification_args_list[] = {
    "info",
    "set",
};

const char *whitelist_args_list[] = {
    "info",
    "range",
    "reset",
};

const char *ntp_args_list[] = {
    "ENA",
    "DIS",
    "info",
    "set",
};

const char *config_args_list[] = {
    "info",
    "load",
};

const char *netconfig_args_list[] = {
    "apply",
    "confirm",
};

const char *history_args_list[] = {
    "EVENTS",
    "UPS",
};

const char *sensor_args_list[] = {
    "info",
    "setup",
};

const char *user_args_list[] = {
    "passwd",
};

/**
  * @brief  Общая структура настроек
  */
extern SETTINGS_t sSettings;

/*
 * Implements the controller's information command.
 */
static portBASE_TYPE prvTaskInfoCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );

/*
 * Implements the reboot command.
 */
static portBASE_TYPE prvTaskRebootCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the systime command.
 */
static portBASE_TYPE prvTaskSystimeCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the ntp command.
 */
static portBASE_TYPE prvTaskNTPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );

/*
 * Implements the network command.
 */
static portBASE_TYPE prvTaskNetworkCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the snmp command.
 */
static portBASE_TYPE prvTaskSNMPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );

/*
 * Implements the AKB command.
 */
static portBASE_TYPE prvTaskAKBCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );

/*
 * Implements the alarm command.
 */
static portBASE_TYPE prvTaskAlarmCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

#ifdef NOTIFICATION_CONTROL_ENABLE
/*
 * Implements the notification command.
 */
static portBASE_TYPE prvTaskNotificationCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );
#endif

#ifdef WHITELIST_ENABLE
/*
 * Implements the whitelist command.
 */
static portBASE_TYPE prvTaskWhiteListCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );
#endif

/*
 * Implements the change password command.
 */
static portBASE_TYPE prvTaskUserCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );

/*
 * Implements the config command.
 */
static portBASE_TYPE prvTaskConfigCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the netconfig command.
 */
static portBASE_TYPE prvTaskNetConfigCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the history command.
 */
static portBASE_TYPE prvTaskHistoryCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the sensor info command.
 */
static portBASE_TYPE prvTaskSensorCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the firmware download http command.
 */
static portBASE_TYPE prvTaskUploadCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString );

/*
 * Implements the ups command.
 */
static portBASE_TYPE prvTaskUPSCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );


/* Structure that defines the "info" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvInfoCommandDefinition = {
    ( const int8_t *const ) "info",  /* The command string to type. */
    ( const int8_t *const ) "\tinfo: вывод информации о контроллере\r\n"
							"\tinfo name <name>: установка поля \"название устройства\"\r\n"
							"\tinfo address <adrr>: установка поля \"адрес расположения контролируемого объекта\"\r\n"
							"\tinfo owner <owner>: установка поля \"организация (собственник)\"\r\n"
							"\tinfo comments <comment>: установка поля \"комментарии\"\r\n",
							prvTaskInfoCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "reboot" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvRebootCommandDefinition = {
    ( const int8_t *const ) "reboot",  /* The command string to type. */
    ( const int8_t *const ) "\treboot: перезагрузка Контроллера\r\n",
    prvTaskRebootCommand, /* The function to run. */
    0 /* No parameters are expected. */
};

/* Structure that defines the "systime" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvSystimeCommandDefinition = {
    ( const int8_t *const ) "systime",  /* The command string to type. */
    ( const int8_t *const ) "\tsystime: вывод системного времени\r\n"
							"\tsystime date <YYYY-MM-DD>: установка даты\r\n"
							"\tsystime time <HH:MM>: установка времени\r\n",
    prvTaskSystimeCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "ntp" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvNTPCommandDefinition = {
    ( const int8_t *const ) "ntp",  /* The command string to type. */
    ( const int8_t *const ) "\tntp ENA|DIS: разрешение/запрет синхронизации времени\r\n"
							"\tntp set IP <A.B.C.D>: установка сервера NTP\r\n"
							"\tntp info: вывод информации о сервере NTP\r\n"
							"\tntp set gmt <SIGN><NUM>: установка часового пояса\r\n",
    prvTaskNTPCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "network" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvNetworkCommandDefinition = {
    ( const int8_t *const ) "network",  /* The command string to type. */
    ( const int8_t *const ) "\tnetwork info вывод информации о текущих сетевых настройках:\r\n"
							"\tnetwork dhcp ENA|DIS: разрешение/запрет получения IP по DHCP\r\n"
							"\tnetwork ip <A.B.C.D>: установка статического IP\r\n"
							"\tnetwork gw <A.B.C.D>: установка шлюза\r\n"
							"\tnetwork mask <A.B.C.D>: установка маски подсети\r\n",
    prvTaskNetworkCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "snmp" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvSNMPCommandDefinition = {
    ( const int8_t *const ) "snmp",  /* The command string to type. */
    ( const int8_t *const ) "\tsnmp info: вывод информации о текущих SNMP настройках\r\n"
							"\tsnmp server <NUM> <A.B.C.D>: установка сервера SNMP\r\n"
							"\tsnmp community read <read>: установка Read community\r\n"
							"\tsnmp community write <write>: установка Write community\r\n",
    prvTaskSNMPCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "akb" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvAKBCommandDefinition = {
    ( const int8_t *const ) "akb",  /* The command string to type. */
    ( const int8_t *const ) "\takb info: вывод информации о параметрах АКБ\r\n"
							"\takb voltcellmin <value>: ввод минимального напряжения на ячейки АКБ (В)\r\n"
							"\takb voltcellmax <value>: ввод максимального напряжения на ячейки АКБ (В)\r\n"
#if HARDWARE_BT6709 || HARDWARE_BT6709_MTS
							"\takb capacity <value>: ввод ёмкости АКБ (Ач)\r\n"
							"\takb voltakb <value>:  ввод номинального напряжения АКБ (В)\r\n"
							"\takb lifetime <value>: ввод срока службы АКБ (лет)\r\n"
							"\takb dataset <YYYY-MM-DD>: ввод даты установки АКБ\r\n"
							"\takb upspower <value>: ввод полной мощности ИБП (ВА)\r\n"
#else if HARDWARE_BT6711
							"\takb capacity <value>: ввод ёмкости АКБ (Ач)\r\n"
							"\takb voltakb <value>:  ввод номинального напряжения АКБ (В)\r\n"
							"\takb upspower <value>: ввод полной мощности ИБП (ВА)\r\n"
#endif							
	,
    prvTaskAKBCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/* Structure that defines the "alarm" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvAlarmCommandDefinition = {
    ( const int8_t *const ) "alarm",  /* The command string to type. */
    ( const int8_t *const ) "\talarm info: вывод информации о параметрах АКБ\r\n"
							"\talarm temp low <value>: ввод нижней границы аварии по температуре (С)\r\n"
							"\talarm temp high <value>: ввод верxней границы аварии по температуре (С)\r\n"
							"\talarm temp hist <value>: ввод гистерезиса аварии по температуре (С)\r\n"
							"\talarm load high <value>: ввод верхней границы аварии по нагрузке (%)\r\n"
							"\talarm load hist <value>: ввод гистерезиса аварии по нагрузке (%)\r\n"
							"\talarm vout low <value>: ввод нижней границы аварии по вых. напряжению (В)\r\n"
							"\talarm vout high <value>: ввод верxней границы аварии по вых. напряжению (В)\r\n"
							"\talarm vout hist <value>: ввод гистерезиса аварии по вых. напряжению (В)\r\n"
#ifdef VAC_IN_MONITOR
							"\talarm vacin low <value>: ввод нижней границы аварии по вх. напряжению (В)\r\n"
							"\talarm vacin high <value>: ввод верxней границы аварии по вх. напряжению (В)\r\n"
							"\talarm vacin hist <value>: ввод гистерезиса аварии по вх. напряжению (В)\r\n"
#endif
    ,prvTaskAlarmCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

#ifdef NOTIFICATION_CONTROL_ENABLE
/* Structure that defines the "notification" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvNotificationCommandDefinition = {
    ( const int8_t *const ) "notification",  /* The command string to type. */
    ( const int8_t *const ) "\tnotification info: вывод списка уведомлений\r\n"
    						"\tnotification set <NUM> ENA|DIS: вкл/выкл уведомления\r\n",
    prvTaskNotificationCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};
#endif

#ifdef  WHITELIST_ENABLE
/* Structure that defines the "whitelist" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvWhiteListCommandDefinition = {
    ( const int8_t *const ) "whitelist",  /* The command string to type. */
    ( const int8_t *const ) "\twhitelist info: вывод информации о текущем белом списке IP адресов контроллера\r\n"
    						"\twhitelist range <NUM> <A.B.C.D/E>: установка диапазона IP адресов\r\n"
                            "\twhitelist reset <NUM>: сброс диапазона IP адресов\r\n",
    prvTaskWhiteListCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};
#endif

/* Structure that defines the "user" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvUserCommandDefinition = {
    ( const int8_t *const ) "user",  /* The command string to type. */
    ( const int8_t *const ) "\tuser passwd <name>: установка пароля для пользователя <name>\r\n",
    prvTaskUserCommand, /* The function to run. */
    2 /* Two parameters are expected, which can take any value. */
};

/* Structure that defines the "config" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvConfigCommandDefinition = {
    ( const int8_t *const ) "config",  /* The command string to type. */
    ( const int8_t *const ) "\tconfig info: вывод информации о состоянии конфигураций\r\n"
    						"\tconfig load default: загрузка конфигурации по умолчанию\r\n",
    prvTaskConfigCommand, /* The function to run. */
    -1 /* Two parameters are expected, which can take any value. */
};

/* Structure that defines the "config" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvNetConfigCommandDefinition = {
    ( const int8_t *const ) "netconfig",  /* The command string to type. */
    ( const int8_t *const ) "\tnetconfig apply: применение конфигурации сетевых настроек\r\n"
    						"\tnetconfig confirm: подтверждение конфигурации сетевых настроек\r\n",
    prvTaskNetConfigCommand, /* The function to run. */
    1 /* Two parameters are expected, which can take any value. */
};

/* Structure that defines the "history" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvHistoryCommandDefinition = {
    ( const int8_t *const ) "history",  /* The command string to type. */
    ( const int8_t *const ) "\thistory show EVENTS|UPS <num_page>:	вывод журнала\r\n",
    prvTaskHistoryCommand, /* The function to run. */
    3 /* Two parameters are expected, which can take any value. */
};

/* Structure that defines the "sensor info" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvSensorCommandDefinition = {
    ( const int8_t *const ) "sensor",  /* The command string to type. */
    ( const int8_t *const ) "\tsensor info: вывод параметров системы (выход из режима Ctrl+C далее Enter)\r\n"

#ifdef DINS_ENABLE
							"\tsensor 	setup DI <num> <state>: установка нормального состояния сухого контакта:\r\n"
							"\t\t\t\t0 - разомкнутое состояние\r\n"
							"\t\t\t\t1 - замкнутое состояние\r\n"
#endif
#ifdef DOUTS_ENABLE
							"\tsensor 	setup DO <num> <issue>: установка источника срабатывания реле:\r\n"
							"\t\t\t\t1 - Наличие сети\r\n"
							"\t\t\t\t2 - Наличие выходного напряжения\r\n"
							"\t\t\t\t3 - Разряд АКБ\r\n"
							"\t\t\t\t4 - Отключение АКБ\r\n"
							"\t\t\t\t5 - SNMP SET\r\n"
#endif
    ,
    prvTaskSensorCommand, /* The function to run. */
    -1 /* No parameters are expected. */
};

/* Structure that defines the "firmware dowmload http" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvUploadCommandDefinition = {
    ( const int8_t *const ) "firmware download http",  /* The command string to type. */
    ( const int8_t *const ) "\tfirmware download http: переход в режим обновления через Web-сервер\r\n",
    prvTaskUploadCommand, /* The function to run. */
    2 /* No parameters are expected. */
};

/* Structure that defines the "ups" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvUPSCommandDefinition = {
    ( const int8_t *const ) "ups",  /* The command string to type. */
    ( const int8_t *const ) "\tups battest <num>: управление процедурой тестирования АКБ:\r\n"
							"\t\t\t\t0 - Остановить тестирование\r\n"
							"\t\t\t\t1-99 - Запустить тест на x минут\r\n"
							"\t\t\t\t100 - Тестирование в течение 10 секунд\r\n"
							"\t\t\t\t999 - Тестирование до разряда\r\n"
							"\tups shutdown <num>: управление отключением нагрузки ИБП:\r\n"
							"\t\t\t\t0 - Остановить процедуру отключения нагрузки\r\n"
							"\t\t\t\tn - Отключить нагрузку через n минут\r\n"
							"\t\t\t\tn: 0.2, 0.3, ..., 1, 2, ..., 10\r\n",
    prvTaskUPSCommand, /* The function to run. */
    2 /* Two parameters are expected, which can take any value. */
};

#ifdef FTP_ENABLE
#include "ftp.h"

#define FTP_ARGS_LIST \
X(info) \
X(server_ip) \
X(server_port) \
X(remote_path) \
X(user) \
X(pass) \
X(run) \

typedef enum {
#define X(name) ARG_FTP_##name,
FTP_ARGS_LIST
#undef X
ARG_FTP_ALL,
} ftp_args_t;
const char *ftp_args_list[] = {
#define X(name) #name,
FTP_ARGS_LIST
#undef X
};

static portBASE_TYPE prvTaskFTPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );
static const CLI_Command_Definition_t prvFTPCommandDefinition = {
    (const int8_t *const)"ftp",  /* The command string to type. */
    (const int8_t *const)"\tftp info: вывод информации о настройках обновления по ftp\r\n"
                         "\tftp server_ip <ip address>: задать адрес FTP-сервера\r\n"
                         "\tftp server_port <port>: задать порт FTP-сервера\r\n"
                         "\tftp remote_path <file path>: задать путь к файлу обновления ПО\r\n"
                         "\tftp user <username>: задать имя пользователя для аутентификации на FTP-сервере\r\n"
                         "\tftp pass <password>: задать пароль для аутентификации на FTP-сервере\r\n"
                         "\tftp run: запустить процесс обновления через FTP\r\n",
    prvTaskFTPCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};
#endif

#ifdef SYSLOG_ENABLE

const char *syslog_args_list[] = {
    "info",
    "ENA",
    "DIS",
    "server_ip",
    "server_port",
};

typedef enum{
    ARG_SYSLOG_INFO = 0,
	ARG_SYSLOG_ENABLE,
	ARG_SYSLOG_DISABLE,
	ARG_SYSLOG_IP,
    ARG_SYSLOG_PORT,
	ARG_SYSLOG_ALL
}syslog_args_t;

static portBASE_TYPE prvTaskSysLogCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );
static const CLI_Command_Definition_t prvSysLogCommandDefinition = {
    (const int8_t *const)"syslog",  /* The command string to type. */
    (const int8_t *const)"\tsyslog info: вывод информации о настройках Syslog\r\n"
                         "\tsyslog ENA|DIS: вкл./выкл. Syslog\r\n"
                         "\tsyslog server_ip <ip address>: установка ip-адреса Syslog-сервера\r\n"
                         "\tsyslog server_port <port>: установка порта Syslog-сервера\r\n",
    prvTaskSysLogCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};
#endif

#ifdef RADIUS_SERVER_ENABLE

const char *radius_args_list[] = {
    "info",
    "ENA",
    "DIS",
    "server_ip",
    "server_port",
    "secret",
};

typedef enum{
    ARG_RADIUS_INFO = 0,
	ARG_RADIUS_ENABLE,
	ARG_RADIUS_DISABLE,
	ARG_RADIUS_IP,
    ARG_RADIUS_PORT,
    ARG_RADIUS_SECRET,
	ARG_RADIUS_ALL
}radius_args_t;

static portBASE_TYPE prvTaskRADIUSCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString );
static const CLI_Command_Definition_t prvRADIUSCommandDefinition = {
    (const int8_t *const)"radius",  /* The command string to type. */
    (const int8_t *const)"\tradius info: вывод информации о настройках RADIUS\r\n"
                         "\tradius ENA|DIS: вкл./выкл. авторизации через RADIUS\r\n"
                         "\tradius server_ip <ip address>: установка ip-адреса RADIUS-сервера\r\n"
                         "\tradius server_port <port>: установка порта RADIUS-сервера\r\n"
                         "\tradius secret <secret>: установка пароля RADIUS-сервера\r\n",
    prvTaskRADIUSCommand, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};
#endif

/* Structure that defines the "quit" command line command.   This
generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t prvQuitCommandDefinition = {
    ( const int8_t *const ) "quit",  /* The command string to type. */
    ( const int8_t *const ) "\tquit: завершение сессии\r\n",
    NULL, /* The function to run. */
    -1 /* The user can enter any number of commands. */
};

/*-----------------------------------------------------------*/

void vRegisterCLICommands( void )
{
    /* Register all the command line commands defined immediately above. */
    FreeRTOS_CLIRegisterCommand( &prvInfoCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvRebootCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvSystimeCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvNTPCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvNetworkCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvSNMPCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvAKBCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvAlarmCommandDefinition );
#ifdef NOTIFICATION_CONTROL_ENABLE
    FreeRTOS_CLIRegisterCommand( &prvNotificationCommandDefinition );
#endif
#ifdef WHITELIST_ENABLE
    FreeRTOS_CLIRegisterCommand( &prvWhiteListCommandDefinition );
#endif
    FreeRTOS_CLIRegisterCommand( &prvUserCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvConfigCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvNetConfigCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvHistoryCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvSensorCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvUploadCommandDefinition );
    FreeRTOS_CLIRegisterCommand( &prvUPSCommandDefinition );
#ifdef FTP_ENABLE
    FreeRTOS_CLIRegisterCommand( &prvFTPCommandDefinition );
#endif
#ifdef SYSLOG_ENABLE
    FreeRTOS_CLIRegisterCommand( &prvSysLogCommandDefinition );
#endif
#ifdef RADIUS_SERVER_ENABLE
    FreeRTOS_CLIRegisterCommand( &prvRADIUSCommandDefinition );
#endif
    FreeRTOS_CLIRegisterCommand( &prvQuitCommandDefinition );
}
/*-----------------------------------------------------------*/

static portBASE_TYPE prvTaskInfoCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t len;
    int8_t num_arg = 0;
    uint8_t i;
    static uint8_t page = 0;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    num_arg = prvGetNumberOfParameters(pcCommandString);
    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    if (num_arg == 0) {
        const int8_t *const pcInfoTableHeader = ( int8_t * )
            "\r\n**************Информация о Контроллере**************\r\n";
        const int8_t *const pcUPSInfoTableHeader = ( int8_t * )
            "\r\n*****************Информация об ИБП******************\r\n";
        if (!page) {
            /* Return the next command help string, before moving the pointer on to
            the next command in the list. */
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInfoTableHeader, strlen( ( char * ) pcInfoTableHeader ) );

            GetWorkTimeStr(str, &len);
            strcat(( char * ) pcWriteBuffer, "Время работы:\t\t\t");
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nМодель:\t\t\t\t");
            GetModelStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nДата производства:\t\t");
            GetProductionDataStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nВерсия ПО:\t\t\t");
            GetVersionStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nMAC адрес:\t\t\t");
            GetMacStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nСерийный номер:\t\t\t");
            GetSerialNumberStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nНазвание устройства:\t\t");
            GetNameDeviceStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nВладелец:\t\t\t");
            GetOwnerStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nМестоположение:\t\t\t");
            GetLocationStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nКомментарии:\t\t\t");
            GetCommentsStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            page = 1;
            xReturn = pdTRUE;
        } else {

            strncat( ( char * ) pcWriteBuffer, ( const char * ) pcUPSInfoTableHeader, strlen( ( char * ) pcUPSInfoTableHeader ) );

            strcat(( char * ) pcWriteBuffer, "\r\nКомпания:\t\t\tАО\"НПК РоТеК\"");

            strcat(( char * ) pcWriteBuffer, "\r\nМодель:\t\t\t\t");
            GetUPSModelStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nСерийный номер:\t\t\t");
            GetUPSSerialStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\nВерсия ПО:\t\t\t");
            GetUPSVersionStr(str, &len);
            strncat(( char * ) pcWriteBuffer, str, len);

            strcat(( char * ) pcWriteBuffer, "\r\n");

            page = 0;
            /* There are no more commands in the list, so there will be no more
            strings to return after this one and pdFALSE should be returned. */
            xReturn = pdFALSE;
        }
    } else if (num_arg == 1) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        xReturn = pdFALSE;
    } else {
        /* Obtain the parameter string. */
        pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
            (
                pcCommandString,        /* The command string itself. */
                xParameterNumber,       /* Return the next parameter. */
                &xParameterStringLength /* Store the parameter string length. */
            );
        for (i = 0; i < INFO_ALL_ARGS; i ++) {
            if ( strncmp( ( const char * ) pcParameterString, info_args_list[i], strlen(info_args_list[i]) ) == 0 
                && xParameterStringLength == strlen(info_args_list[i])) {
                break;
            }
        }
        xParameterNumber ++;
        //  xParameterNumber ++;
        /* Obtain the parameter string. */
        pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
            (
                pcCommandString,        /* The command string itself. */
                xParameterNumber,       /* Return the next parameter. */
                &xParameterStringLength /* Store the parameter string length. */
            );
        memset(str, 0, sizeof(str));
        xParameterStringLength = strlen(( const char * ) pcParameterString);
        if (xParameterStringLength > (int32_t)sizeof(str)) {
            xParameterStringLength = sizeof(str) - 1;
        }
        strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
        if (control_string_en_digit(str, strlen(str))) {
            switch (i) {
                case INFO_DEV_NAME:
                    if (cli_state->user_id == ADMIN) {
                        str[19] = 0;
                        SetNameDeviceStr(str);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
                    }
                    break;
                case INFO_ADDRESS:
                    if (cli_state->user_id == ADMIN) {
                        str[109] = 0;
                        SetLocation(str);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
                    }
                    break;
                case INFO_OWNER:
                    if (cli_state->user_id == ADMIN) {
                        str[49] = 0;
                        SetOwner(str);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
                    }
                    break;
                case INFO_COMMENTS:
                    if (cli_state->user_id == ADMIN) {
                        str[109] = 0;
                        SetComment(str);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
                    }
                    break;
                default:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
            }
            if (i >= INFO_DEV_NAME && i <= INFO_COMMENTS) {
                cli_save_config(cli_state);
            }
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        xReturn = pdFALSE;
    }

    return xReturn;
}

static portBASE_TYPE prvTaskRebootCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{

    static bool start_reboot = true;
    const int8_t *const pcRebootHeader = ( int8_t * )
        "Контроллер будет перезагружен через 1 секунду\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;

    if (cli_state->user_id != ADMIN) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    if (start_reboot) {
        start_reboot = false;
        strcpy( ( char * ) pcWriteBuffer, ( char * ) pcRebootHeader );
        return pdTRUE;
    } else {
        Reboot(CLI_ACT);
        return pdFALSE;
    }
}

static portBASE_TYPE prvTaskSystimeCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t len;
    uint8_t i;
    uint8_t fail = 0;
    uint16_t temp = 0;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        const int8_t *const pcInfoTableHeader = ( int8_t * )
            "\r\n******Системное время Контроллера******\r\n";
        /* Return the next command help string, before moving the pointer on to
        the next command in the list. */
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInfoTableHeader, strlen( ( char * ) pcInfoTableHeader ) );

        GetDateStr(str, &len);
        strcat(( char * ) pcWriteBuffer, "Дата:\t\t\t");
        strncat(( char * ) pcWriteBuffer, str, len);

        strcat(( char * ) pcWriteBuffer, "\r\nВремя:\t\t\t");
        GetTimeStr(str, &len);
        strncat(( char * ) pcWriteBuffer, str, len);

        strcat(( char * ) pcWriteBuffer, "\r\n");

        /* There are no more commands in the list, so there will be no more
        strings to return after this one and pdFALSE should be returned. */
        xReturn = pdFALSE;
    } else {
        if (cli_state->user_id != ADMIN) {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
            return pdFALSE;
        }
        for (i = 0; i < ARG_SYSTIME_ALL; i ++) {
            if ( strncmp( ( const char * ) pcParameterString, systime_args_list[i], strlen(systime_args_list[i]) ) == 0 
                && xParameterStringLength == strlen(systime_args_list[i])) {
                break;
            }
        }
        if (i != ARG_SYSTIME_ALL) {
            if (sSettings.sSNTP.sntpEnable) {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcSystymeDenied, strlen( ( char * ) pcSystymeDenied ) );
                return pdFALSE;
            }
        }

        xParameterNumber ++;
        /* Obtain the parameter string. */
        pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
            (
                pcCommandString,        /* The command string itself. */
                xParameterNumber,       /* Return the next parameter. */
                &xParameterStringLength /* Store the parameter string length. */
            );
        if (pcParameterString == NULL) {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            return pdFALSE;
        }
        memset(str, 0, sizeof(str));
        xParameterStringLength = strlen(( const char * ) pcParameterString);
        if (xParameterStringLength > (int32_t)sizeof(str)) {
            xParameterStringLength = sizeof(str) - 1;
        }
        strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
        switch (i) {
            case ARG_SYSTIME_DATA:
                if (xParameterStringLength == 10) {
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if (j != 4 && j != 7) {
                            if (str[j] > 0x39 || str[j] < 0x30) {
                                fail = 1;
                            }
                        } else if (j == 4 || j == 7) {
                            if (str[j] != '-') {
                                fail = 1;
                            }
                        }
                    }
                    if (!fail) {
                        temp = 1000 * (str[0] - 0x30) + 100 * (str[1] - 0x30) + 10 * (str[2] - 0x30) + str[3] - 0x30;
                        if (temp > 2099 || temp < 2000) {
                            fail = 1;
                        }
                        temp = 0;
                        temp = 10 * (str[5] - 0x30) + (str[6] - 0x30);
                        if (temp > 12) {
                            fail = 1;
                        }
                        temp = 0;
                        temp = 10 * (str[8] - 0x30) + (str[9] - 0x30);
                        if (temp > 31) {
                            fail = 1;
                        }
                    }
                } else {
                    fail = 1;
                }
                if (!fail) {
                    SetDateStr(str);
                    cli_save_config(cli_state);
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            case ARG_SYSTIME_TIME:
                if (xParameterStringLength == 5) {
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if (j != 2) {
                            if (str[j] > 0x39 || str[j] < 0x30) {
                                fail = 1;
                            }
                        } else if (j == 2) {
                            if (str[j]  != ':') {
                                fail = 1;
                            }
                        }
                    }
                    if (!fail) {
                        temp = 10 * (str[0] - 0x30) + (str[1] - 0x30);
                        if (temp > 23) {
                            fail = 1;
                        }
                        temp = 0;
                        temp = 10 * (str[3] - 0x30) + (str[4] - 0x30);
                        if (temp > 59) {
                            fail = 1;
                        }
                    }
                } else {
                    fail = 1;
                }
                if (!fail) {
                    SetTimeStr(str);
                    cli_save_config(cli_state);
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
        xReturn = pdFALSE;
    }

    return xReturn;
}

/*
 * Implements the ntp command.
 */
static portBASE_TYPE prvTaskNTPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    char str_temp[110];
    uint8_t len;
    uint8_t i;
    bool enable_old_sntp;

    const int8_t *const pcInfoTableHeader = ( int8_t * )
        "\r\n************NTP настройки Контроллера************\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_NTP_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, ntp_args_list[i], strlen(ntp_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(ntp_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_NTP_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    xParameterNumber ++;
    if (pcParameterString == NULL) {
        switch (i) {
            case ARG_NTP_ENABLE:
                enable_old_sntp = sSettings.sSNTP.sntpEnable;
                SetSntpStateStr("1");
                if (sSettings.sSNTP.sntpEnable != enable_old_sntp) {
                    cli_save_config(cli_state);
                }
                break;
            case ARG_NTP_DISABLE:
                enable_old_sntp = sSettings.sSNTP.sntpEnable;
                SetSntpStateStr("0");
                if (sSettings.sSNTP.sntpEnable != enable_old_sntp) {
                    cli_save_config(cli_state);
                }
                break;
            case ARG_NTP_INFO:
                /* Return the next command help string, before moving the pointer on to
                the next command in the list. */
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInfoTableHeader, strlen( ( char * ) pcInfoTableHeader ) );

                GetSntpStateStrRU(str, &len);
                strcat(( char * ) pcWriteBuffer, "Режим установки времени:\t");
                strncat(( char * ) pcWriteBuffer, str, len);

                strcat(( char * ) pcWriteBuffer, "\r\nIP адрес NTP сервера:\t\t");
                GetSntpServerIpStr(str, &len);
                strncat(( char * ) pcWriteBuffer, str, len);

                strcat(( char * ) pcWriteBuffer, "\r\nЧасовой пояс:\t\t\t");
                GetSntpTimeZoneStr(str, &len);
                strncat(( char * ) pcWriteBuffer, str, len);

                strcat(( char * ) pcWriteBuffer, "\r\nПоследняя дата синхронизации:\t");
                GetSntpLastDataStr(str, &len);
                strncat(( char * ) pcWriteBuffer, str, len);

                strcat(( char * ) pcWriteBuffer, "\r\n");
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
        return pdFALSE;
    }

    if (i == ARG_NTP_SET) {
        memset(str, 0, sizeof(str));
        if (xParameterStringLength > (int32_t)sizeof(str)) {
            xParameterStringLength = sizeof(str) - 1;
        }
        strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
        pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
            (
                pcCommandString,        /* The command string itself. */
                xParameterNumber,       /* Return the next parameter. */
                &xParameterStringLength /* Store the parameter string length. */
            );
        if (pcParameterString != NULL) {
            memset(str_temp, 0, sizeof(str_temp));
            if (xParameterStringLength > (int32_t)sizeof(str_temp)) {
                xParameterStringLength = sizeof(str_temp) - 1;
            }
            strncat(str_temp, ( const char * ) pcParameterString, xParameterStringLength);
            if (strncmp(str, "IP", 2) == 0) {
                if (xParameterStringLength <= 15) {
                    if (ipaddr_addr(str_temp) != IPADDR_NONE) {
                        if (strncmp(str_temp, sSettings.sSNTP.ip, strlen(str_temp)) != 0) {
                            SetSntpServerIpStr(str_temp);
                            cli_save_config(cli_state);
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else if (strncmp(str, "gmt", 3) == 0) {
                if (xParameterStringLength > 1 && xParameterStringLength < 5) {
                    bool fail = false;
                    if (str_temp[0] != '-' && str_temp[0] != '+') {
                        fail = true;
                    }
                    if (!isdigit_int(str_temp[1]) && (!isdigit_int(str_temp[2]) && str_temp[2] != '.') && (!isdigit_int(str_temp[3]) &&
                            str_temp[3] != '.')) {
                        fail = true;
                    }
                    if (xParameterStringLength == 5) {
                        if (!isdigit_int(str_temp[4])) {
                            fail = true;
                        }
                    }
                    if (!fail) {
                        float value = atof(str_temp);
                        if (value >= -12.0 && value <= 12.0) {
                            SetSntpTimeZoneStr(str_temp);
                            cli_save_config(cli_state);
                        } else {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
    } else {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
    }
    xReturn = pdFALSE;

    return xReturn;
}

/*
 * Implements the network command.
 */
static portBASE_TYPE prvTaskNetworkCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_NETWORK_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, network_args_list[i], strlen(network_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(network_args_list[i])) {
            break;
        }
    }
    if (cli_state->user_id != ADMIN && i != ARG_NETWORK_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }
    if (i != ARG_NETWORK_ALL && i != ARG_NETWORK_DHCP && i != ARG_NETWORK_INFO) {
        if (sSettings.sWebTempParams.dhcpEnable) {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
            return pdFALSE;
        }
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        if (i == ARG_NETWORK_INFO) {
            net_config_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }
    memset(str, 0, sizeof(str));
    xParameterStringLength = strlen(( const char * ) pcParameterString);
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 1;
    }
    strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
    switch (i) {
        case ARG_NETWORK_DHCP:
            if (strncmp(str, "ENA", 3) == 0) {
                SetUDPDhcpStateStr("True");
                strcpy( ( char * ) pcWriteBuffer,
                    "\t\tСохраните конфигурацию сетевых настроек\r\n" );
            } else if (strncmp(str, "DIS", 3) == 0) {
                SetUDPDhcpStateStr("False");
                strcpy( ( char * ) pcWriteBuffer,
                    "\t\tСохраните конфигурацию сетевых настроек\r\n" );
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_NETWORK_IP:
            if (xParameterStringLength <= 15) {
                if (ipaddr_addr(str) != IPADDR_NONE) {
                    SetIPStr(str);
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tСохраните конфигурацию сетевых настроек\r\n" );
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_NETWORK_GW:
            if (xParameterStringLength <= 15) {
                if (ipaddr_addr(str) != IPADDR_NONE) {
                    SetGatewayStr(str);
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tСохраните конфигурацию сетевых настроек\r\n" );
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_NETWORK_MASK:
            if (xParameterStringLength <= 15) {
                if (ipaddr_addr(str) != IPADDR_NONE) {
                    SetMaskStr(str);
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tСохраните конфигурацию сетевых настроек\r\n" );
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;

    return xReturn;
}

/*
 * Implements the snmp command.
 */
static portBASE_TYPE prvTaskSNMPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[20];
    char temp_str[20];
    uint8_t i;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_SNMP_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, snmp_args_list[i], strlen(snmp_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(snmp_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_SNMP_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }
    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    xParameterNumber ++;
    if (pcParameterString == NULL) {
        if (i == ARG_SNMP_INFO) {
            snmp_config_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }
    memset(str, 0, sizeof(str));
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 1;
    }
    strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
    switch (i) {
        case ARG_SNMP_SERVER:
            if (xParameterStringLength == 1 && isdigit_int(str[0])) {
                int32_t temp = atoi(str);
                if (temp > 0 && temp < 6) {
                    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                        (
                            pcCommandString,        /* The command string itself. */
                            xParameterNumber,       /* Return the next parameter. */
                            &xParameterStringLength /* Store the parameter string length. */
                        );
                    if (pcParameterString != NULL) {
                        memset(str, 0, sizeof(str));
                        xParameterStringLength = strlen(( const char * ) pcParameterString);
                        if (xParameterStringLength > (int32_t)sizeof(str)) {
                            xParameterStringLength = sizeof(str) - 1;
                        }
                        strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
                        if (xParameterStringLength <= 15) {
                            if (ipaddr_addr(str) != IPADDR_NONE) {
                                switch (temp) {
                                    case 1:
                                        SetManagerIp(str);
                                        break;
                                    case 2:
                                        SetManagerIp2(str);
                                        break;
                                    case 3:
                                        SetManagerIp3(str);
                                        break;
                                    case 4:
                                        SetManagerIp4(str);
                                        break;
                                    case 5:
                                        SetManagerIp5(str);
                                        break;
                                }
                                if (temp > 0 && temp < 6) {
                                    cli_save_config(cli_state);
                                }
                            } else {
                                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            }
                        } else {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_SNMP_COMMUNITY:
            pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                (
                    pcCommandString,        /* The command string itself. */
                    xParameterNumber,       /* Return the next parameter. */
                    &xParameterStringLength /* Store the parameter string length. */
                );
            if (pcParameterString != NULL) {
                memset(temp_str, 0, sizeof(temp_str));
                xParameterStringLength = strlen(( const char * ) pcParameterString);
                if (xParameterStringLength > (int32_t)sizeof(temp_str)) {
                    xParameterStringLength = sizeof(temp_str) - 1;
                }
                strncat(temp_str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
                if (control_string_en_digit(temp_str, strlen(temp_str))) {
                    if (strncmp(str, "read", 4) == 0) {
                        SetReadCommunity(temp_str);
                        cli_save_config(cli_state);
                    } else if (strncmp(str, "write", 5) == 0) {
                        SetWriteCommunity(temp_str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;


    return xReturn;
}

/*
 * Implements the akb command.
 */
static portBASE_TYPE prvTaskAKBCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i;
	uint8_t fail = 0;
	uint16_t temp = 0;
    float value = 0;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_AKB_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, akb_args_list[i], strlen(akb_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(akb_args_list[i])) {
            break;
        }
    }
    if (cli_state->user_id != ADMIN && i != ARG_AKB_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        if (i == ARG_AKB_INFO) {
            akb_config_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }
    memset(str, 0, sizeof(str));
    xParameterStringLength = strlen(( const char * ) pcParameterString);
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 2;
    }
    strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
#if HARDWARE_BT6709 || HARDWARE_BT6709_MTS 
	if (i != ARG_AKB_DATASET)
#endif
	{
		for (uint8_t j = 0; j < xParameterStringLength; j ++) {
			if (!isfloatdigit(str[j])) {
				strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
				return pdFALSE;
			}
		}
		value = atof(str);
	}

    switch (i) {
        case ARG_AKB_VOLT_CELL_MIN:
            if (value < sSettings.UPS_Setting.Ucellmax && value >= MIN_VOLT_CELL_RANGE) {
                SetUPSVoltCellMinStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_AKB_VOLT_CELL_MAX:
            if (value > sSettings.UPS_Setting.Ucellmin && value <= MAX_VOLT_CELL_RANGE) {
                SetUPSVoltCellMaxStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
#if HARDWARE_BT6709 || HARDWARE_BT6709_MTS || HARDWARE_BT6711
        case ARG_AKB_CAPACITY:
            if (value >= CAPACITY_MIN_RANGE && value <= CAPACITY_MAX_RANGE && (value - (int32_t)value) == 0) {
                SetCapacityNominalAKBStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_AKB_VOLT:
            if (value >= AKB_VOLTAGE_MIN_RANGE && value <= AKB_VOLTAGE_MAX_RANGE && ((int32_t)value % 12) == 0 && (value - (int32_t)value) == 0) {
                SetVoltageAKBNominalStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
#ifndef HARDWARE_BT6711
        case ARG_AKB_LIFETIME:
            if (value >= LIFETIME_MIN_RANGE && value <= LIFETIME_MAX_RANGE  && (value - (int32_t)value) == 0) {
                SetLifeTimeAKBStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
		case ARG_AKB_DATASET:
                if (xParameterStringLength == 10) {
                    if (strncmp( str, "0000-00-00", 10) == 0) {
                        memset(str, 0, sizeof(str));
                        SetDataSetAKBStr(str);
                        SETTINGS_Save();
                        xReturn = pdFALSE;
                        return xReturn;
                    }
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if (j != 4 && j != 7) {
                            if (str[j] > 0x39 || str[j] < 0x30) {
                                fail = 1;
                            }
                        } else if (j == 4 || j == 7) {
                            if (str[j] != '-') {
                                fail = 1;
                            }
                        }
                    }
                    if (!fail) {
                        temp = 1000 * (str[0] - 0x30) + 100 * (str[1] - 0x30) + 10 * (str[2] - 0x30) + str[3] - 0x30;
                        if (temp > 2099 || temp < 2000) {
                            fail = 1;
                        }
                        temp = 0;
                        temp = 10 * (str[5] - 0x30) + (str[6] - 0x30);
                        if (temp > 12) {
                            fail = 1;
                        }
                        temp = 0;
                        temp = 10 * (str[8] - 0x30) + (str[9] - 0x30);
                        if (temp > 31) {
                            fail = 1;
                        }
                    }
                } else {
                    fail = 1;
                }
                if (!fail) {
                    SetDataSetAKBStr(str);
                    cli_save_config(cli_state);
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
			break;
#endif
        case ARG_AKB_UPS_POWER:
            if (value >= UPS_POWER_MIN_RANGE && value <= UPS_POWER_MAX_RANGE && ((int32_t)value % 50) == 0 && (value - (int32_t)value) == 0) {
                SetUPSPowerStr(str);
                cli_save_config(cli_state);
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
#endif
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;
    return xReturn;
}

/*
 * Implements the alarm command.
 */
static portBASE_TYPE prvTaskAlarmCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i, j;
    float value = 0;
    uint8_t k;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_ALARM_TYPE_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, type_alarm_args_list[i], strlen(type_alarm_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(type_alarm_args_list[i])) {
            break;
        }
    }
    if (cli_state->user_id != ADMIN && i != ARG_ALARM_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        if (i == ARG_ALARM_INFO) {
            alarm_config_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }

    for (j = 0; j < ARG_ALARM_ALL; j ++) {
        if ( strncmp( ( const char * ) pcParameterString, alarm_args_list[j], strlen(alarm_args_list[j]) ) == 0 ) {
            break;
        }
    }


    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    memset(str, 0, sizeof(str));
    xParameterStringLength = strlen(( const char * ) pcParameterString);
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 2;
    }
    strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
    switch (i) {
        case ARG_ALARM_TEMP:
            switch (j) {
                case ARG_ALARM_LINE_LOW:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            if (k == 0 && str[k] == '-') {
                                continue;
                            } else {
                                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                                return pdFALSE;
                            }
                        }
                    }
                    value = atof(str);
                    if (value >= MIN_TEMP_MIN_RANGE && value <= MIN_TEMP_MAX_RANGE) {
                        SetTemperatureAlarmLowRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIGH:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MAX_TEMP_MIN_RANGE && value <= MAX_TEMP_MAX_RANGE) {
                        SetTemperatureAlarmHighRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIST:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isfloatdigit(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= HIST_TEMP_MIN_RANGE && value <= HIST_TEMP_MAX_RANGE) {
                        SetTemperatureAlarmHisteStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                default:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
            }
            break;
        case ARG_ALARM_LOAD:
            switch (j) {
                case ARG_ALARM_LINE_LOW:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
                case ARG_ALARM_LINE_HIGH:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MAX_LOAD_MIN_RANGE && value <= MAX_LOAD_MAX_RANGE) {
                        SetLoadAlarmHighRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIST:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isfloatdigit(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= HIST_LOAD_MIN_RANGE && value <= HIST_LOAD_MAX_RANGE) {
                        SetLoadAlarmHistStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                default:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
            }
            break;
        case ARG_ALARM_VOUT:
            switch (j) {
                case ARG_ALARM_LINE_LOW:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MIN_VAC_MIN_RANGE && value <= MIN_VAC_MAX_RANGE) {
                        SetVACAlarmLowRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIGH:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MAX_VAC_MIN_RANGE && value <= MAX_VAC_MAX_RANGE) {
                        SetVACAlarmHighRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIST:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= HIST_VAC_MIN_RANGE && value <= HIST_VAC_MAX_RANGE) {
                        SetVACAlarmHisteStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                default:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
            }
            break;
#ifdef VAC_IN_MONITOR
        case ARG_ALARM_VACIN:
            switch (j) {
                case ARG_ALARM_LINE_LOW:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MIN_VAC_MIN_RANGE && value <= MIN_VAC_MAX_RANGE) {
                        SetVACInputAlarmLowRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIGH:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= MAX_VAC_MIN_RANGE && value <= MAX_VAC_MAX_RANGE) {
                        SetVACInputAlarmHighRangeStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                case ARG_ALARM_LINE_HIST:
                    for (k = 0; k < xParameterStringLength; k ++) {
                        if (!isdigit_int(str[k])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    value = atof(str);
                    if (value >= HIST_VAC_MIN_RANGE && value <= HIST_VAC_MAX_RANGE) {
                        SetVACinputAlarmHisteStr(str);
                        cli_save_config(cli_state);
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                    break;
                default:
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    break;
            }
            break;
#endif
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;


    return xReturn;
}

#ifdef NOTIFICATION_CONTROL_ENABLE
/*
 * Implements the notification command.
 */
static portBASE_TYPE prvTaskNotificationCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[20];
    char temp_str[20];
    uint8_t i;
    char *beginValue;
    uint8_t len;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_NOTIFICATION_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, notification_args_list[i], strlen(notification_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(notification_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_NOTIFICATION_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }
    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    xParameterNumber ++;
    if (pcParameterString == NULL) {
        if (i == ARG_NOTIFICATION_INFO) {
            notification_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }
    memset(str, 0, sizeof(str));
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 1;
    }
    strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
    switch (i) {
        case ARG_NOTIFICATION_SET:
            if (xParameterStringLength >= 1) {
                for(uint32_t k = 0; k < xParameterStringLength; k ++) {
                    if (!isdigit_int(str[k])) {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                         return pdFALSE;
                    }
                }
                int32_t temp = atoi(str);
                uint8_t value_notification = 0;
                if (temp > 0 && temp < ALL_TRAPS) {
                    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                        (
                            pcCommandString,        /* The command string itself. */
                            xParameterNumber,       /* Return the next parameter. */
                            &xParameterStringLength /* Store the parameter string length. */
                        );
                    if (pcParameterString != NULL && xParameterStringLength == 3) {
                        if (strncmp(pcParameterString, "ENA", 3) == 0) {
                            value_notification = 1;
                            SetNotificationFlagsStr(&value_notification, (uint8_t)temp);
                            SETTINGS_Save();
                        } else if (strncmp(pcParameterString, "DIS", 3) == 0) {
                            SetNotificationFlagsStr(&value_notification, (uint8_t)temp);
                            SETTINGS_Save();
                        } else {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;
    return xReturn;
}
#endif

#ifdef WHITELIST_ENABLE
/*
 * Implements the whitelist command.
 */
static portBASE_TYPE prvTaskWhiteListCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[20];
    char temp_str[20];
    uint8_t i;
    char *beginValue;
    uint8_t len;
    int32_t temp;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_WHITELIST_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, whitelist_args_list[i], strlen(whitelist_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(whitelist_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_WHITELIST_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }
    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    xParameterNumber ++;
    if (pcParameterString == NULL) {
        if (i == ARG_WHITELIST_INFO) {
            whitelist_config_param(pcWriteBuffer);
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
        return pdFALSE;
    }
    memset(str, 0, sizeof(str));
    if (xParameterStringLength > (int32_t)sizeof(str)) {
        xParameterStringLength = sizeof(str) - 1;
    }
    strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
    switch (i) {
        case ARG_WHITELIST_RANGE:
            if (xParameterStringLength == 1 && isdigit_int(str[0])) {
                temp = atoi(str);
                if (temp > 0 && temp < 6) {
                    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                        (
                            pcCommandString,        /* The command string itself. */
                            xParameterNumber,       /* Return the next parameter. */
                            &xParameterStringLength /* Store the parameter string length. */
                        );
                    if (pcParameterString != NULL) {
                        memset(str, 0, sizeof(str));
                        xParameterStringLength = strlen(( const char * ) pcParameterString);
                        if (xParameterStringLength > (int32_t)sizeof(str)) {
                            xParameterStringLength = sizeof(str) - 1;
                        }
                        strncat(str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
                        if (xParameterStringLength <= 19) {
                            beginValue = strpbrk(str, "/");
                            if (beginValue == NULL) {
                                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                                return pdFALSE;
                            }
                            int32_t mask = atoi(&beginValue[1]);
                            len = beginValue - str;
                            memset(temp_str, 0, sizeof(temp_str));
                            strncpy(temp_str, str, len);
                            for (uint8_t j = (len + 1); j < xParameterStringLength; j++) {
                                if (!isdigit_int(str[j])) {
                                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                                    return pdFALSE;
                                }
                            }
                            if (ipaddr_addr(temp_str) != IPADDR_NONE && (mask <= 32 && mask >= 0)) {
                                SetWhiteListSTR(str, (temp - 1));
                                strcpy( ( char * ) pcWriteBuffer,
                                    "\t\tСохраните конфигурацию сетевых настроек\r\n" );
                            } else {
                                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            }
                        } else {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_WHITELIST_RESET:
            if (xParameterStringLength == 1 && isdigit_int(str[0])) {
                temp = atoi(str);
                if (temp > 0 && temp < 6) {
                    memset(str, 0, sizeof(str));
                    SetWhiteListSTR(str, (temp - 1));
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tСохраните конфигурацию сетевых настроек\r\n" );
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;


    return xReturn;
}
#endif

/*
 * Implements the change password command.
 */
static portBASE_TYPE prvTaskUserCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    uint8_t i;
    char temp_str[MAX_WEB_LOGIN_LEN];
    char WebLogin[MAX_WEB_LOGIN_LEN];
    uint8_t valueLen, user_id;

    const int8_t *const pcChangePWDHeader = ( int8_t * ) "\r\nВведите новый пароль:";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);

    if (cli_state->user_id != ADMIN) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_USER_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, user_args_list[i], strlen(user_args_list[i]) ) == 0 ) {
            break;
        }
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (i == ARG_USER_PWD) {
        memset(temp_str, 0, sizeof(temp_str));
        xParameterStringLength = strlen(( const char * ) pcParameterString);
        if (xParameterStringLength > (int32_t)sizeof(temp_str)) {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        } else {
            strncat(temp_str, ( const char * ) pcParameterString, strlen(( const char * ) pcParameterString));
            for (user_id = 0; user_id < MAX_WEB_USERS; user_id++) {

                GetUserLogin(user_id, WebLogin, &valueLen);

                /* Check login and password */
                if (strncmp(WebLogin, temp_str, MAX_WEB_LOGIN_LEN) == 0) {

                    /* Login and pass are valid */
                    cli_state->id_change_pwd = user_id;
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcChangePWDHeader, strlen( ( char * ) pcChangePWDHeader ) );
                    cli_state->input_state = CLI_CHANGE_PWD;
                    break;
                }
            }
            if (cli_state->input_state != CLI_CHANGE_PWD) {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
        }
    } else {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
    }

    xReturn = pdFALSE;


    return xReturn;
}

/*
 * Implements the config command.
 */
static portBASE_TYPE prvTaskConfigCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i;
    static uint8_t config_menu = 0;

    const int8_t *const pcInfoTableHeader = ( int8_t * )
        "\r\n*********Конфигурация Контроллера*********\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_CONFIG_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, config_args_list[i], strlen(config_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(config_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_CONFIG_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        switch (i) {
            case ARG_CONFIG_INFO:
                switch (config_menu) {
                    case PARAM_CONFIG_SNMP:
                        /* Return the next command help string, before moving the pointer on to
                        the next command in the list. */
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInfoTableHeader, strlen( ( char * ) pcInfoTableHeader ) );
                        snmp_config_param(pcWriteBuffer);
                        break;
#ifdef DINS_ENABLE || DOUTS_ENABLE
                    case PARAM_CONFIG_INOUTS:
                        inouts_config_param(pcWriteBuffer);
                        break;
#endif
#ifdef SYSLOG_ENABLE
	                case PARAM_CONFIG_SYSLOG:
                        syslog_config_param(pcWriteBuffer);
                        break;
#endif
#ifdef RADIUS_SERVER_ENABLE
	                case PARAM_CONFIG_RADIUS:
                        radius_config_param(pcWriteBuffer);
                        break;
#endif
                    case PARAM_CONFIG_AKB:
                        akb_config_param(pcWriteBuffer);
                        break;
                    case PARAM_CONFIG_ALARM:
                        alarm_config_param(pcWriteBuffer);
                        break;
#ifdef WHITELIST_ENABLE
                    case PARAM_CONFIG_WHITELIST:
                        whitelist_config_param(pcWriteBuffer);
                        break;
#endif
                    case PARAM_CONFIG_NET:
                        net_config_param(pcWriteBuffer);
                        break;
                    case PARAM_CONFIG_TIME:
                        time_config_param(pcWriteBuffer);
                        break;
                }

                config_menu ++;
                if (config_menu == PARAM_CONFIG_ALL) {
                    config_menu = 0;
                    return pdFALSE;
                } else {
                    return pdTRUE;
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
        return pdFALSE;
    }
    if (i == ARG_CONFIG_LOAD) {
        memset(str, 0, sizeof(str));
        xParameterStringLength = strlen(( const char * ) pcParameterString);
        if (xParameterStringLength > (int32_t)sizeof(str)) {
            xParameterStringLength = sizeof(str) - 1;
        }
        strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
        if (xParameterStringLength < 13) {
            if (strncmp(str, "default", 7) == 0) {
                SNMP_SendUserTrap(DEVICE_RESTORED);
                log_event_data(LOG_SYSTEM_DEFCONFIG, "Администратор");
                vTaskDelay(500);
                SETTINGS_SetPartDefault();
                cli_save_config(cli_state);
                syslog_str(SYSLOG_INFORMATIONAL, "Сброс настроек (Администратор)");
                strcpy( ( char * ) pcWriteBuffer,
                    "\t\tНастройки сброшены к настройкам по умолчанию!\r\n");
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
    } else {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
    }

    xReturn = pdFALSE;


    return xReturn;
}

/*
 * Implements the config command.
 */
static portBASE_TYPE prvTaskNetConfigCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    portBASE_TYPE xParameterNumber = 1;
    signed portBASE_TYPE xParameterStringLength;
    uint8_t i;
    static start = 0;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );

    for (i = 0; i < ARG_NETCONFIG_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, netconfig_args_list[i], strlen(netconfig_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(netconfig_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    switch (i) {
        case ARG_NETCONFIG_APPLY:
            if (!start) {
                /* Если параметры WEB изменились выставляем флаг, сохраняем настройки и перезагружаемся */
                if (GetStateWebReinit() == true) {
                    start = 1;
                    SetWebReinitFlag(true);
                    cli_save_config(cli_state);
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tНастройки сохранены! Контроллер будет перезагружен\r\n\tПосле перезагрузки подтвердите изменения сетевых настроек\r\n");
                    return pdTRUE;

                }
            } else {
                start = 0;
                vTaskDelay(1010);
                Reboot(CLI_ACT);
            }
            break;
        case ARG_NETCONFIG_CONFIRM:
            SetWebReinitFlag(false);
            SetConfirmWebParamsFlag();
            strcpy( ( char * ) pcWriteBuffer, "\t\tСетевые настройки подтверждены!\r\n");
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }

    return pdFALSE;

}

/*
 * Implements the history command.
 */
static portBASE_TYPE prvTaskHistoryCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i;
    static int16_t num_page = 0;
    static int16_t num_page_temp = 1;
    static bool start = true;

    const int8_t *const pcUPShistoryTableHeader = ( int8_t * )
        "\r\n***********Журнал событий ИБП***********\r\n";
    const int8_t *const pcControllerHistoryTableHeader = ( int8_t * )
        "\r\n***********Журнал событий Контроллера***********\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    if ( strncmp( ( const char * ) pcParameterString, "show", xParameterStringLength ) != 0 ) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );

    for (i = 0; i < ARG_HISTORY_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, history_args_list[i], strlen(history_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(history_args_list[i])) {
            break;
        }
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    memset(str, 0, sizeof(str));
    if (xParameterStringLength > 5) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }
    strncat(str, ( const char * ) pcParameterString, xParameterStringLength);

    if (num_page == 0) {
        num_page = atoi(str);
        if (num_page <= 0) {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            return pdFALSE;
        }
    }

    switch (i) {
        case ARG_HISTORY_EVENTS:
            if (start) {
                start = false;
                /* Return the next command help string, before moving the pointer on to
                the next command in the list. */
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcControllerHistoryTableHeader,
                    strlen( ( char * ) pcControllerHistoryTableHeader ) );
                memset(str, 0, sizeof(str));
                strcat(( char * ) pcWriteBuffer, "\r\n");
                sprintf(str, "Количество страниц журнала: %d\r\n", History_GetPageCount());
                strncat(( char * ) pcWriteBuffer, str, strlen(str));
                strcat(( char * ) pcWriteBuffer, "\r\n");

                if (num_page > History_GetPageCount()) {
                    num_page = History_GetPageCount();
                }
            }

            History_GetPage_tabs(( char * ) pcWriteBuffer, num_page_temp);

            num_page --;
            num_page_temp ++;
            if (num_page == 0) {
                num_page = 0;
                num_page_temp = 1;
                start = true;
                xReturn = pdFALSE;
            } else {
                xReturn = pdTRUE;
            }
            break;
        case ARG_HISTORY_UPS:
            if (start) {
                start = false;
                /* Return the next command help string, before moving the pointer on to
                the next command in the list. */
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcUPShistoryTableHeader,
                    strlen( ( char * ) pcUPShistoryTableHeader ) );
                memset(str, 0, sizeof(str));
                sprintf(str, "Количество страниц журнала: %d\r\n", LOG_GetPageCount());
                strncat(( char * ) pcWriteBuffer, str, strlen(str));

                if (num_page > LOG_GetPageCount()) {
                    num_page = LOG_GetPageCount();
                }
            }

            LOG_GetPage_tabs(( char * ) pcWriteBuffer, num_page_temp);

            num_page --;
            num_page_temp ++;
            if (num_page == 0) {
                num_page = 0;
                num_page_temp = 1;
                start = true;
                xReturn = pdFALSE;
            } else {
                xReturn = pdTRUE;
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            xReturn = pdFALSE;
            break;
    }

    return xReturn;
}

/*
 * Implements the sensor info command.
 */
static portBASE_TYPE prvTaskSensorCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    uint8_t i;
    char str[10];
    char temp_str[10];
    int32_t val = 0, val2 = 0;
    uint8_t fail = 0;
    static uint8_t config_menu = 0;
    uint8_t MAX_CONFIG_PARAM = 0;

#ifdef DINS_ENABLE || DOUTS_ENABLE
    MAX_CONFIG_PARAM = 3;
#else
    MAX_CONFIG_PARAM = 2;
#endif

    const int8_t *const pcSensorTableHeader = ( int8_t * )
        "\r\n*********Параметры Контроллера*********\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_SENSOR_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, sensor_args_list[i], strlen(sensor_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(sensor_args_list[i])) {
            break;
        }
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        if (i == ARG_SENSOR_INFO) {
            switch (config_menu) {
                case 0:
                    /* Return the next command help string, before moving the pointer on to
                    the next command in the list. */
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcSensorTableHeader, strlen( ( char * ) pcSensorTableHeader ) );
                    ups_sensor_param(pcWriteBuffer);
                    break;
                case 1:
                    ups_sensor_akb_param(pcWriteBuffer);
                    break;
#ifdef DINS_ENABLE || DOUTS_ENABLE
                case 2:
                    inouts_sensor_param(pcWriteBuffer);
                    break;
#endif
            }

            config_menu ++;
            if (config_menu == MAX_CONFIG_PARAM) {
                config_menu = 0;
                return pdFALSE;
            } else {
                return pdTRUE;
            }
        } else {
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        }
    } else {
        switch (i) {
#ifdef DINS_ENABLE || DOUTS_ENABLE
            case ARG_SENSOR_SETUP:
                if (cli_state->user_id != ADMIN) {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
                    return pdFALSE;
                }
                memset(str, 0, sizeof(str));
                if (xParameterStringLength > (int32_t)sizeof(str)) {
                    xParameterStringLength = sizeof(str) - 1;
                }
                strncat(str, ( const char * ) pcParameterString, xParameterStringLength);
                if (xParameterStringLength < 3) {
                    xParameterNumber ++;
                    /* Obtain the parameter string. */
                    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                        (
                            pcCommandString,        /* The command string itself. */
                            xParameterNumber,       /* Return the next parameter. */
                            &xParameterStringLength /* Store the parameter string length. */
                        );
                    memset(temp_str, 0, sizeof(str));
                    if (xParameterStringLength > 1) {
                        fail = 1;
                        break;
                    }
                    strncat(temp_str, ( const char * ) pcParameterString, xParameterStringLength);
                    if (!isdigit_int(temp_str[0])) {
                        fail = 1;
                        break;
                    }
                    val = atoi(temp_str);

                    xParameterNumber ++;
                    /* Obtain the parameter string. */
                    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
                        (
                            pcCommandString,        /* The command string itself. */
                            xParameterNumber,       /* Return the next parameter. */
                            &xParameterStringLength /* Store the parameter string length. */
                        );
                    memset(temp_str, 0, sizeof(str));
                    if (xParameterStringLength > 1) {
                        fail = 1;
                        break;
                    }
                    strncat(temp_str, ( const char * ) pcParameterString, xParameterStringLength);
                    if (!isdigit_int(temp_str[0])) {
                        fail = 1;
                        break;
                    }
                    fail = 1;
#ifdef DINS_ENABLE
                    if (strncmp(str, "DI", 2) == 0) {
                        if (val != 1) {
                            break;
                        }

                        val2 = atoi(temp_str);
                        if (val2 < 0 || val2 > 1) {
                            break;
                        }
                        SetDINTypeActStr(temp_str, (val - 1));
                        cli_save_config(cli_state);
                        fail = 0;
                    }
#endif
#ifdef DOUTS_ENABLE 
                    if (strncmp(str, "DO", 2) == 0) {
                        if (val < 1 || val > 3) {
                            break;
                        }

                        val2 = atoi(temp_str);
                        if (val2 < 1 || val2 > 5) {
                            break;
                        }
                        SetROTypeActStr(temp_str, (val - 1));
                        cli_save_config(cli_state);
                        fail = 0;
                    }
                }
#endif 
                break;
#endif
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
    }

    if (fail) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
    }

    xReturn = pdFALSE;


    return xReturn;
}

/*
 * Implements the firmware download http command.
 */
static portBASE_TYPE prvTaskUploadCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen,
    const int8_t *pcCommandString )
{
    static bool start_update = true;
    const int8_t *const pcUploadHeader = ( int8_t * )
        "Контроллер переводится в режим загрузчика\r\n";

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;

    if (cli_state->user_id != ADMIN) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    if (start_update) {
        start_update = false;
        strcpy( ( char * ) pcWriteBuffer, ( char * ) pcUploadHeader );
        return pdTRUE;
    } else {
        HTTP_StartResetTask(true);
        return pdFALSE;
    }
}

/*
 * Implements the ups command.
 */
static portBASE_TYPE prvTaskUPSCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    int32_t val = 0;
    float val_float = 0;
    int8_t res = 0;
    uint8_t i;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);

    if (cli_state->user_id != ADMIN) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    for (i = 0; i < ARG_UPS_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, ups_args_list[i], strlen(ups_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(ups_args_list[i])) {
            break;
        }
    }
    xParameterNumber ++;

    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    memset(str, 0, sizeof(str));
    if (xParameterStringLength > 3) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }
    strncat(str, ( const char * ) pcParameterString, xParameterStringLength);

    switch (i) {
        case ARG_UPS_BATTEST:
            for (uint8_t j = 0; j < xParameterStringLength; j++) {
                if (!isdigit_int(str[j])) {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    return pdFALSE;
                }
            }
            val = atoi(str);
            if (val == 0) {
                res = ups_metac_service_pdu(ups_cancel_test);
                set_act_source(CLI_ACT);
                if (res == 1) {
                    log_event_data(LOG_TEST_UPS, "Администратор (Останов)");
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Останов теста\" принята ИБП!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Останов теста\" отклонена ИБП!\r\n");
                }
            } else if (val > 0 && val < 100) {
                TimeParam = val;
                res = ups_metac_service_pdu(ups_test_time);
                if (res == 1) {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" принята ИБП!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" отклонена ИБП!\r\n");
                }
            } else if (val == 100) {
                res = ups_metac_service_pdu(ups_test_10sec);
                if (res == 1) {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" принята ИБП!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" отклонена ИБП!\r\n");
                }
            } else if (val == 999) {
                res = ups_metac_service_pdu(ups_test_low_bat);
                if (res == 1) {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" принята ИБП!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tКоманда \"Запуск теста\" отклонена ИБП!\r\n");
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        case ARG_UPS_SHUTDOWN:
            for (uint8_t j = 0; j < xParameterStringLength; j++) {
                if (!isfloatdigit(str[j])) {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    return pdFALSE;
                }
            }
            val_float = atof(str);
            if (val_float == 0) {
                res = ups_metac_service_pdu(ups_cancel_shut_down);
                if (res == 1) {
                    log_event_data(LOG_SHUTDOWN_UPS, "Администратор (Останов)");
                    strcpy( ( char * ) pcWriteBuffer, "\t\t\tВыключение нагрузки ИБП отменено!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer,
                        "\t\tВыключение нагрузки ИБП не удалось отменить!\r\n");
                }
            } else if (val_float > 0 && val_float <= 10) {
                TimeParamFloat = val_float;
                res = ups_metac_service_pdu(ups_shutdown);
                if (res == 1) {
                    log_event_data(LOG_SHUTDOWN_UPS, "Администратор");
                    strcpy( ( char * ) pcWriteBuffer, "\t\tОтключение нагрузки ИБП!\r\n");
                } else {
                    strcpy( ( char * ) pcWriteBuffer, "\t\tОтключение нагрузки ИБП не удалось!\r\n");
                }
            } else {
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            }
            break;
        default:
            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
            break;
    }
    xReturn = pdFALSE;

    return xReturn;
}

#ifdef SYSLOG_ENABLE
static portBASE_TYPE  prvTaskSysLogCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    char str_temp[110];
    uint8_t len;
    uint8_t i;
    bool enable_old_syslog;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_SYSLOG_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, syslog_args_list[i], strlen(syslog_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(syslog_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_SYSLOG_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        switch (i) {
            case ARG_SYSLOG_INFO:
                /* Return the next command help string, before moving the pointer on to
                the next command in the list. */
                syslog_config_param(pcWriteBuffer);
                break;
            case ARG_SYSLOG_ENABLE:
                enable_old_syslog = sSettings.sSyslog.enabled;
                SetSyslogEnable("on");
                if (sSettings.sSyslog.enabled != enable_old_syslog) {
                    cli_save_config(cli_state);
                }
                break;
            case ARG_SYSLOG_DISABLE:
                enable_old_syslog = sSettings.sSyslog.enabled;
                SetSyslogEnable("off");
                if (sSettings.sSyslog.enabled != enable_old_syslog) {
                    cli_save_config(cli_state);
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
    } else {
        memset(str_temp, 0, sizeof(str_temp));
        if (xParameterStringLength > (int32_t)sizeof(str_temp)) {
            xParameterStringLength = sizeof(str_temp) - 1;
        }
        strncat(str_temp, ( const char * ) pcParameterString, xParameterStringLength);
        switch (i) {
            case ARG_SYSLOG_IP:
                if (xParameterStringLength <= 15) {
                    if (ipaddr_addr(str_temp) != IPADDR_NONE) {
                        GetSyslogServer(str, &len);
                        if (strncmp(str_temp, str, strlen(str_temp)) != 0) {
                            SetSyslogServer(str_temp);
                            cli_save_config(cli_state);
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            case ARG_SYSLOG_PORT:
                if (xParameterStringLength <= 5) {
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if (!isdigit_int(str_temp[j])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    int temp = atoi(str_temp);
                    if (temp > 0 && temp < 65535) {
                        GetSyslogPort(str, &len);
                        if (strncmp(str_temp, str, strlen(str_temp)) != 0) {
                            SetSyslogPort(str_temp);
                            cli_save_config(cli_state);
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }     
    }

    xReturn = pdFALSE;

    return xReturn;    
}
#endif

#ifdef RADIUS_SERVER_ENABLE
static portBASE_TYPE  prvTaskRADIUSCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
    int8_t *pcParameterString;
    signed portBASE_TYPE xParameterStringLength, xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    char str_temp[110];
    uint8_t len;
    uint8_t i;
    bool enable_old_radius;

    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
        return pdFALSE;
    }

    for (i = 0; i < ARG_RADIUS_ALL; i ++) {
        if ( strncmp( ( const char * ) pcParameterString, radius_args_list[i], strlen(radius_args_list[i]) ) == 0 
            && xParameterStringLength == strlen(radius_args_list[i])) {
            break;
        }
    }

    if (cli_state->user_id != ADMIN && i != ARG_RADIUS_INFO) {
        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPermissionDenied, strlen( ( char * ) pcPermissionDenied ) );
        return pdFALSE;
    }

    xParameterNumber ++;
    /* Obtain the parameter string. */
    pcParameterString = ( int8_t * ) FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    if (pcParameterString == NULL) {
        switch (i) {
            case ARG_RADIUS_INFO:
                /* Return the next command help string, before moving the pointer on to
                the next command in the list. */
                radius_config_param(pcWriteBuffer);
                break;
            case ARG_RADIUS_ENABLE:
                enable_old_radius = sSettings.sRADIUS.RDSEnable;
                SetRDSEnableStateStr("on");
                if (sSettings.sRADIUS.RDSEnable != enable_old_radius) {
                    cli_save_config(cli_state);
                }
                break;
            case ARG_RADIUS_DISABLE:
                enable_old_radius = sSettings.sRADIUS.RDSEnable;
                SetRDSEnableStateStr("off");
                if (sSettings.sRADIUS.RDSEnable != enable_old_radius) {
                    cli_save_config(cli_state);
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }
    } else {
        memset(str_temp, 0, sizeof(str_temp));
        if (xParameterStringLength > (int32_t)sizeof(str_temp)) {
            xParameterStringLength = sizeof(str_temp) - 1;
        }
        strncat(str_temp, ( const char * ) pcParameterString, xParameterStringLength);
        switch (i) {
            case ARG_RADIUS_IP:
                if (xParameterStringLength <= 15) {
                    if (ipaddr_addr(str_temp) != IPADDR_NONE) {
                        GetRDSIpStr(str, &len);
                        if (strncmp(str_temp, str, strlen(str_temp)) != 0) {
                            SetRDSIpStr(str_temp);
                            cli_save_config(cli_state);
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            case ARG_RADIUS_PORT:
                if (xParameterStringLength <= 5) {
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if (!isdigit_int(str_temp[j])) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    int temp = atoi(str_temp);
                    if (temp > 0 && temp < 65535) {
                        GetRDSPortStr(str, &len);
                        if (strncmp(str_temp, str, strlen(str_temp)) != 0) {
                            SetRDSPortStr(str_temp);
                            cli_save_config(cli_state);
                        }
                    } else {
                        strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            case ARG_RADIUS_SECRET:
                if (xParameterStringLength <= 17) {
                    for (uint8_t j = 0; j < xParameterStringLength; j++) {
                        if ( str_temp[j] < 33 || str_temp[j] > 127 ) {
                            strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                            return pdFALSE;
                        }
                    }
                    GetRDSPasswordkStr(str, &len);
                    if (strncmp(str_temp, str, strlen(str_temp)) != 0) {
                        SetRDSPasswordkStr(str_temp);
                        cli_save_config(cli_state);
                    }
                } else {
                    strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                }
                break;
            default:
                strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcInvalidCommand, strlen( ( char * ) pcInvalidCommand ) );
                break;
        }     
    }

    xReturn = pdFALSE;

    return xReturn;    
}
#endif

#ifdef FTP_ENABLE
#pragma GCC diagnostic error "-Wall"
#pragma GCC diagnostic error "-Wextra"
static portBASE_TYPE prvTaskFTPCommand(cli_state_t *cli_state, int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString)
{
    int8_t *pcParameterString;
    unsigned portBASE_TYPE xParameterStringLength;
    signed portBASE_TYPE xReturn;
    portBASE_TYPE xParameterNumber = 1;
    char str[110];
    uint8_t i;

    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);

    if (cli_state->user_id != ADMIN && i != ARG_FTP_info) {
        strncpy((char *)pcWriteBuffer, (const char *)pcPermissionDenied, strlen((char *)pcPermissionDenied));
        return pdFALSE;
    }

    /* Obtain the subcommand */
    pcParameterString = (int8_t *)FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    for (i = 0; i < ARG_FTP_ALL; i++) {
        if (strncmp((const char *)pcParameterString, ftp_args_list[i], strlen(ftp_args_list[i])) == 0
            && xParameterStringLength == strlen(ftp_args_list[i])) {
            break;
        }
    }
    xParameterNumber++;

    /* Obtain the subcommand parameter */
    pcParameterString = (int8_t *)FreeRTOS_CLIGetParameter
        (
            pcCommandString,        /* The command string itself. */
            xParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
        );
    memset(str, 0, sizeof(str));
    strncat(str, (const char *) pcParameterString, xParameterStringLength);

    switch (i) {
        case ARG_FTP_info:
            ;
            snprintf((char *)pcWriteBuffer, configCOMMAND_INT_MAX_OUTPUT_SIZE, "\r\n"
                     "*******************Настройки FTP********************\r\n"
                     "Адрес сервера: \t\t%s\r\n"
                     "Порт: \t\t\t%u\r\n"
                     "Путь к файлу: \t\t%s\r\n"
                     "Имя пользователя: \t%s\r\n"
                     "Пароль: \t\t%s\r\n",
                     ipaddr_ntoa(&sSettings.sFTPUpdate.server_ip),
                     sSettings.sFTPUpdate.server_port,
                     sSettings.sFTPUpdate.remote_path,
                     sSettings.sFTPUpdate.user,
                     sSettings.sFTPUpdate.pass);
            break;
        case ARG_FTP_server_ip:
            ;
            ip_addr_t server_ip_old = sSettings.sFTPUpdate.server_ip;
            if (!ipaddr_aton(str, &sSettings.sFTPUpdate.server_ip)) {
                strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
                return pdFALSE;
            }
            if (!ip_addr_cmp(&sSettings.sFTPUpdate.server_ip, &server_ip_old)) {
                cli_save_config(cli_state);
            }
            break;
        case ARG_FTP_server_port:
            ;
            u16_t server_port_old = sSettings.sFTPUpdate.server_port;
            int temp = atoi(str);
            if (temp < 1 || temp > 65535) {
                strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
                return pdFALSE;
            } else {
                sSettings.sFTPUpdate.server_port = temp;
                if (sSettings.sFTPUpdate.server_port != server_port_old) {
                    cli_save_config(cli_state);
                }
            }
            break;
        case ARG_FTP_remote_path: {
            if (xParameterStringLength < 1 || xParameterStringLength >= sizeof(sSettings.sFTPUpdate.remote_path)) {
                strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
                return pdFALSE;
            } else {
                strcpy(&sSettings.sFTPUpdate.remote_path, str);
                cli_save_config(cli_state);
            }
            break; }
        case ARG_FTP_user: {
            if (xParameterStringLength < 1 || xParameterStringLength >= sizeof(sSettings.sFTPUpdate.user)) {
                strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
                return pdFALSE;
            } else {
                strcpy(&sSettings.sFTPUpdate.user, str);
                cli_save_config(cli_state);
            }
            break; }
        case ARG_FTP_pass: {
            if (xParameterStringLength < 1 || xParameterStringLength >= sizeof(sSettings.sFTPUpdate.pass)) {
                strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
                return pdFALSE;
            } else {
                strcpy(&sSettings.sFTPUpdate.pass, str);
                cli_save_config(cli_state);
            }
            break; }
        case ARG_FTP_run: {
            static bool ran = false;
            if (ran) {
                vTaskDelay(500 / portTICK_PERIOD_MS);
                char *status = get_ftp_progress();
                unsigned statuslen = strlen(status);
                sprintf((char *)pcWriteBuffer, "Статус обновления по FTP: %s%%\r\n", status);
                // stop polling when we get an error message or 100%
                bool resume = statuslen < 3;
                if (!resume) {
                    ran = false;
                }
                return resume;
            } else {
                // run!
                ftpcfg.settings = &sSettings.sFTPUpdate;
                start_ftp_client(&ftpcfg);
                strcpy((char *)pcWriteBuffer, "Начато обновление ПО по FTP\r\n");
                ran = true;
                // tell the caller to poll us for more data
                return pdTRUE;
            }
            break; }
        default:
            strcpy((char *)pcWriteBuffer, (const char *)pcInvalidCommand);
            break;
    }
    xReturn = pdFALSE;

    return xReturn;
}
#endif // FTP_ENABLE
/*-----------------------------------------------------------*/