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

#include "cli.h"
#include <string.h>
#include "FreeRTOS.h"
#include "task.h"
#include "FreeRTOS_CLI.h"
#include "CLI_Commands.h"
#include "settings_api.h"
#include "parameters.h"
#include "control_symbol.h"
#include "log.h"
#include "web_params_api.h"
#include "tinystdio.h"

#define ISO_nl       0x0a
#define ISO_cr       0x0d

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

uint8_t id_change_pwd = 0;

const int8_t * const pcWarningMessage = ( const int8_t * ) "Количество соединенений превышено. Данное соединение будет закрыто\r\n";
#ifdef HARDWARE_BT6709
const int8_t * const pcWelcomeMessage = ( const int8_t * ) "BT-6709 command server - connection accepted.\r\nlogin:";
#else
const int8_t * const pcWelcomeMessage = ( const int8_t * ) "BT-6707 command server - connection accepted.\r\nlogin:";
#endif
static const int8_t * const pcEndOfCommandOutputString = ( int8_t * ) "\r\n[Нажмите клавишу ENTER для повторного выполнения предыдущей команды]\r\n>";
extern int8_t cOutputBuffer[ configCOMMAND_INT_MAX_OUTPUT_SIZE ];
cli_state_t cli_states[MAX_SESSIONS];

void SensorInfoTimerCallback(TimerHandle_t pxTimer) {
	portBASE_TYPE xReturned = pdTRUE;
	uint8_t num_timer;
	for(uint8_t i = 0; i < MAX_SESSIONS; i ++){
		if(pxTimer == cli_states[i].RepeatSensorInfoTimer){
			num_timer = i;
			break;
		}
	}
	do
	{
		/* Ensure there is not a string lingering in
		the output buffer. */
		cOutputBuffer[ 0 ] = 0x00;
		// TODO
		//xReturned = FreeRTOS_CLIProcessCommand( "sensor info", cOutputBuffer, configCOMMAND_INT_MAX_OUTPUT_SIZE );
		cli_states[num_timer].send(cli_states[num_timer].num_connect, cOutputBuffer, strlen( ( const char * ) cOutputBuffer ));

	} while( xReturned != pdFALSE );
	xTimerStart(cli_states[num_timer].RepeatSensorInfoTimer, 0);
}

static portBASE_TYPE FreeRTOS_CLIAuthProcess( int8_t * pcWriteBuffer, cli_state_t *s  )
{
	portBASE_TYPE xReturn = pdTRUE;
	uint32_t len;
	uint8_t valueLen, user_id;
	char WebPassword[MAX_WEB_PASSWD_LEN];
	char WebLogin[MAX_WEB_LOGIN_LEN];
	char password[cmdMAX_INPUT_SIZE] = { 0 };
	const int8_t * const pcPSWHeader = ( int8_t * ) "\r\npassword:";
	const int8_t * const pcLoginHeader = ( int8_t * ) "\r\nlogin:";

	memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);

	switch(s->input_state){
	case CLI_AUTH:
		memset(s->login, 0, MAX_WEB_LOGIN_LEN);
		len = strlen(s->buf);
		if(len < MAX_WEB_LOGIN_LEN){
			strncpy(s->login, s->buf, len);
			//sendopt(s, TELNET_WILL, TELOPT_ECHO);
			strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcPSWHeader, strlen( ( char * ) pcPSWHeader ) );
			s->input_state = CLI_AUTH_PASSW;
			xReturn = pdTRUE;
		}
		else{
			xReturn = pdFALSE;
		}
		break;
	case CLI_AUTH_PASSW:
		//sendopt(s, TELNET_WONT, TELOPT_ECHO);
		memset(name_login_telnet, 0, 50);
		memset(password, 0, MAX_WEB_PASSWD_LEN);
		len = strlen(s->buf);
		strncpy(password, s->buf, len);
		for (user_id = 0; user_id < MAX_WEB_USERS; user_id++) {

			GetUserLogin(user_id, WebLogin, &valueLen);
			GetUserPassword(user_id, WebPassword, &valueLen);

			/* Check login and password */
			if ((strncmp(WebLogin, s->login, MAX_WEB_LOGIN_LEN) == 0) &&
				(strncmp(WebPassword, password, MAX_WEB_PASSWD_LEN) == 0)) {

				/* Login and pass are valid */
				s->user_id = user_id;
				s->login_err = 0;
				strcpy( ( char * ) pcWriteBuffer, "\r\nАвторизация успешно пройдена\r\n>" );
				s->input_state = CLI_CMD;
				switch (user_id) {
				  case 0:
					  snprintf(name_login_telnet, sizeof(name_login_telnet), "Администратор");
					  break;
				  case 1:
					  snprintf(name_login_telnet, sizeof(name_login_telnet), "Пользователь");
					  break;
				  default:
					  break;
				}

				log_event_data(LOG_LOGIN_TELNET, name_login_telnet);
				xReturn = pdTRUE;
				break;
			}
			else{
				xReturn = pdFALSE;
			}
		}
		break;
	default:
		xReturn = pdFALSE;
		s->input_state = CLI_AUTH;
		return xReturn;
		break;
	}

	if(xReturn == pdFALSE){
		s->input_state = CLI_AUTH;
		if(s->login_err < 4){
			s->login_err ++;
			strcpy( ( char * ) pcWriteBuffer, "\r\nОшибка авторизации\r\n" );
			strncat( ( char * ) pcWriteBuffer, ( const char * ) pcLoginHeader, strlen( ( char * ) pcLoginHeader ) );
			xReturn = pdTRUE;
		}
		else{
			s->login_err = 0;
			xReturn = pdFALSE;
		}
	}

	return xReturn;
}

static portBASE_TYPE FreeRTOS_ChangePWDProcess( int8_t * pcWriteBuffer, cli_state_t *s  )
{
	portBASE_TYPE xReturn = pdTRUE;
	uint32_t len;
	static char password[ MAX_WEB_PASSWD_LEN ] = { 0 };
	char password2[ MAX_WEB_PASSWD_LEN ] = { 0 };
	const int8_t * const pcNewPSWHeader = ( int8_t * ) "\r\nВведите повторно новый пароль:";

	memset(pcWriteBuffer, 0, configCOMMAND_INT_MAX_OUTPUT_SIZE);

	len = strlen(s->buf);
	if(s->input_state == CLI_CHANGE_PWD){
		memset(password, 0, MAX_WEB_PASSWD_LEN);
		if(len >= MAX_WEB_PASSWD_LEN){
			strcpy( ( char * ) pcWriteBuffer, "\r\nОшибка при вводе нового пароля\r\n>" );
			s->input_state = CLI_CMD;
		} else {
			if(!control_string_en_digit(s->buf, len)){
				strcpy( ( char * ) pcWriteBuffer, "\r\nОшибка при вводе нового пароля\r\n>" );
				s->input_state = CLI_CMD;
			} else {
				strncpy(password, s->buf, len);
				strncpy( ( char * ) pcWriteBuffer, ( const char * ) pcNewPSWHeader, strlen( ( char * ) pcNewPSWHeader ) );
				s->input_state = CLI_CHANGE_PWD_ACK;
			}
		}
	} else {
		s->input_state = CLI_CHANGE_PWD;
		memset(password2, 0, cmdMAX_INPUT_SIZE);
		if(len >= MAX_WEB_LOGIN_LEN){
			strcpy( ( char * ) pcWriteBuffer, "\r\nОшибка при вводе нового пароля\r\n>" );
			s->input_state = CLI_CMD;
		} else {
			strncpy(password2, s->buf, len);

			if (strncmp(password, password2, MAX_WEB_PASSWD_LEN) == 0) {
				memcpy(sSettings.sAuth[id_change_pwd].password, password, 11);
				telnet_act = true;
				HTTP_SaveSettings();
				log_event_data(LOG_PSW_CHANGE, name_login_telnet);
				strcpy( ( char * ) pcWriteBuffer, "\r\nПароль успешно изменен\r\n>" );
				s->input_state = CLI_CMD;
				xReturn = pdTRUE;
			} else {
				strcpy( ( char * ) pcWriteBuffer, "\r\nОшибка при вводе нового пароля\r\n>" );
				s->input_state = CLI_CMD;
			}
		}
	}

	return xReturn;
}


static void cli_input(cli_state_t *s)
{
	portBASE_TYPE xReturned;

	switch(s->input_state){
		case CLI_AUTH:
		case CLI_AUTH_PASSW:
			if(FreeRTOS_CLIAuthProcess(cOutputBuffer, s)){
				s->send(s->num_connect, cOutputBuffer, strlen( ( const char * ) cOutputBuffer ));
				memset( s->buf, 0x00, cmdMAX_INPUT_SIZE );
			}
			else{
				s->state = STATE_CLOSE;
			}
			break;
		case CLI_CMD:
			/* The input string has been terminated.  Was the
			input a quit command? */
			if( strcmp( "quit", ( const char * ) s->buf ) == 0 )
			{
				s->state = STATE_CLOSE;
			}
			else
			{
				/* The input string was not a quit command.
				Pass the string to the command interpreter. */

				/* See if the command is empty, indicating that the last command is
				to be executed again. */
				if( s->bufptr == 0 )
				{
					if(s->flag_telnet_ip_option ){
						s->flag_telnet_ip_option = false;
						return;
					}
					else{
						strcpy( s->buf, s->prev_cmd );
					}
				}

				/* Transmit a line separator, just to make the
				output easier to read. */
				s->send(s->num_connect, "\r\n", strlen( "\r\n" ));

				do
				{
					/* Ensure there is not a string lingering in
					the output buffer. */
					cOutputBuffer[ 0 ] = 0x00;
                                        // FIXME telnetState should go into the command processor
					//input_state = s->input_state;
					xReturned = FreeRTOS_CLIProcessCommand(s, s->buf, cOutputBuffer, configCOMMAND_INT_MAX_OUTPUT_SIZE );
					//s->input_state = input_state;
					s->send(s->num_connect, cOutputBuffer, strlen( ( const char * ) cOutputBuffer ));

				} while( xReturned != pdFALSE );

				if( strcmp( "sensor info", ( const char * ) s->buf ) == 0 ){
					strcpy( s->prev_cmd, s->buf );
					memset( s->buf, 0x00, cmdMAX_INPUT_SIZE );
					xTimerStart(s->RepeatSensorInfoTimer, 0);
				}
				else{

					/* All the strings generated by the input
					command have been sent.  Clear the input
					string ready to receive the next command.
					Remember the command that was just processed
					first in case it is to be processed again. */
					strcpy( s->prev_cmd, s->buf );
					memset( s->buf, 0x00, cmdMAX_INPUT_SIZE );
					if(s->input_state != CLI_CHANGE_PWD)
						s->send(s->num_connect, pcEndOfCommandOutputString, strlen( ( const char * ) pcEndOfCommandOutputString ));
				}
			}
			break;
		case CLI_CHANGE_PWD:
		case CLI_CHANGE_PWD_ACK:
			FreeRTOS_ChangePWDProcess(cOutputBuffer, s);
			s->send(s->num_connect, cOutputBuffer, strlen( ( const char * ) cOutputBuffer ));
			memset( s->buf, 0x00, cmdMAX_INPUT_SIZE );
			break;

	}
}

void cli_getchar(cli_state_t *s, char incoming_char)
{
	s->buf[s->bufptr] = incoming_char;

	bool echo_enabled = true;	// FIXME
	if(echo_enabled && s->input_state != CLI_AUTH_PASSW){
		if(s->buf[s->bufptr] != 0x03 && s->buf[s->bufptr] != 0x7f){
			s->send( s->num_connect, &s->buf[s->bufptr], 1);
		}
	}
	else if(s->input_state == CLI_AUTH_PASSW){
		s->send( s->num_connect, " ", 1);
	}


  if(s->buf[s->bufptr] == ISO_nl ||
	s->buf[s->bufptr] == 0) {
	s->bufptr = 0;
    return;
  }

  if(s->buf[s->bufptr] == ISO_cr ||
     s->bufptr == sizeof(s->buf) - 1) {
    if(s->bufptr > 0) {
      s->buf[s->bufptr] = 0;
    }
    cli_input(s);
    s->bufptr = 0;
  } else if( s->buf[s->bufptr] == '\b' || s->buf[s->bufptr] == 0x7f)
	{
		/* Backspace was pressed.  Erase the last
		character in the string - if any. */
	  	s->buf[s->bufptr] = '\0';
		if( s->bufptr > 0 )
		{
			s->bufptr--;
			s->buf[s->bufptr] = '\0';
		}
	}
  else if (s->buf[s->bufptr] == 0x03){
	  xTimerStop(s->RepeatSensorInfoTimer, 0);
	  s->flag_telnet_ip_option = true;
	  if(s->input_state != CLI_CHANGE_PWD && s->input_state != CLI_CHANGE_PWD_ACK)
	  	s->send( s->num_connect, pcEndOfCommandOutputString, strlen( ( const char * ) pcEndOfCommandOutputString ));
  }
  else {
    ++s->bufptr;
  }
}