开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
tw_cli.c.svn-base
资源名称：cli.rar　[点击查看]
上传用户：hujq123
上传日期：2016-04-10
资源大小：153k
文件大小：47k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

tw_cli.c.svn-base：源码内容
  1. /* 
  2.  * Copyright (C) 2002 Koninklijke Philips Electronics N.V., 
  3.  * All Rights Reserved. 
  4.  *
  5.  * This source code and any compilation or derivative thereof is the 
  6.  * proprietary information of Koninklijke Philips Electronics N.V. 
  7.  * and is confidential in nature. 
  8.  * Under no circumstances is this software to be exposed to or placed 
  9.  * under an Open Source License of any type without the expressed 
  10.  * written permission of Koninklijke Philips Electronics N.V. 
  11.  * 
  12.  *###########################################################
  13.  */ 
  14. /*! 
  15.  *   file    tw_cli.c 
  16.  * 
  17.  *   brief   - 
  18.  * 
  19.  */ 
  20. /*-----------------------------------------------------------*
  21.  * 
  22.  *   %version:    6 % 
  23.  *   instance:    DS_6 
  24.  *   %date_created:  Fri Feb 21 08:04:49 2003 % 
  25.  *
  26.  *###########################################################
  27.  */ 
  32. /****************************************************************************
  33. *
  34. *
  35. * This module is writen to support 2 or more sessions.  Everything that is
  36. * specific to a session is stored in a Cli_cmdSession_t object.  There are two
  37. * such objects in sockSession[] array right now.
  38. *
  39. * To truely support multisession, the caller of these routines must provide
  40. * either 2 threads or some kind of nselect() services.
  41. *
  42. *
  43. *
  44. * CLI Style Guide
  45. * ---------------
  46. * All commands and options are all in lower case.
  47. *
  48. * In the help string, if there are optional parameters accompanying the
  49. * command, put the optional parameters within a braces "{}".  All lowercase
  50. * word means that user can type the exact same form.  Multiple
  51. * selections within the same field are seperated by "|".  All uppercase
  52. * word means that user needs to type an appropriate value for the field.
  53. *
  54. * Even though the CLI parser support multiple hierachy, try not to have more
  55. * than 3 levels deep.
  56. *
  57. * Philips history
  58. * who   When Why
  59. * KBL   6/14/99  And God set them in the firmament of the heavens to give 
  60. *    light upon the earth,  
  61. *
  62. *****************************************************************************/
  63. #include <stdio.h>
  64. #include <stdlib.h>
  65. #include <unistd.h>
  66. #include <stdarg.h>
  67. #include <string.h>
  68. #include <ctype.h>
  69. #include <inttypes.h>
  70. #include <tw_cli.h>
  72. /* All command structure objects adhere to following naming convention :
  73.  *
  74.  * If the object is at root, meaning that it's a command and not a option,
  75.  * start with "CliRco", otherwise start with "CliCo".
  76.  * Next comes the actual command+option in concatenated form, e.g. "show abc"
  77.  * will be "showAbc".
  78.  *
  79.  * All handler must start with "CliXXXProc_" (handler with no argument) or 
  80.  * "CliXXXVoproc" (handler with arguments - variations and options).  Help 
  81.  * function must start with "CliXXXHelp".  XXX is either Rco or Co, depends
  82.  * if the handler is attached to a root command or sub command.
  83.  *
  84.  * All root command objects must be included in the "Cli_AllRootCmdObjList"
  85.  * list in this file.  Definition of this object, as well as its child
  86.  * command objects and handlers must be placed in its own file.
  87.  */
  89. /* Root commands are application specific. */
  91. extern Cli_CmdStruct_t  *Cli_AllRootCmdObjList[];
  94. /*** STOP !  There is no need to venture below this line if ***
  95.  ***  all you need is to add a root command object.  ***/
  99. //#define   NUM_ALL_CMD_OBJ  (sizeof(Cli_AllRootCmdObjList) / sizeof(Cli_CmdStruct_t *))
  102. /* Foundation for support for multiple CLI session is here.  The following functions;
  103.  * Cli_Sock2sess(), Cli_NewSess(), and Cli_FreeSess() are initially implemented as
  104.  * macros and will only work for 2 sessions.
  105.  */
  106. #define    NUM_OF_CLI_ACCESS_SESSION  3
  109. static Cli_CmdStruct_t  Cli_WorkingRootCmdObj = 
  110. { 
  111. "@root",
  112. 0,
  113. Cli_AllRootCmdObjList,
  114. "--",
  115. NULL,
  116. NULL,
  117. NULL
  118. };
  121. static Cli_cmdSession_t  sockSession[NUM_OF_CLI_ACCESS_SESSION];
  124. /* Convert from socket and pointer to a Session, return pSess if successful,
  125.  * otherwise NULL.  Writen for 2 sessions only.
  126.  */
  127. #define  Cli_Sock2Sess(so)  ( (so) == sockSession[0].pSessFuns ?  
  128.   &(sockSession[0]) :   
  129.   ((so) == sockSession[1].pSessFuns ? &(sockSession[1]) : NULL) )
  131. /* Common size text string to be reused.
  132.  */
  133. char *badPasswordStr  = "nInvalid Password.n";
  134. char *endSessionStr   = "nCLI session terminated.n";
  135. char *noHelpStr   = "nNo help available.n";
  136. char *missingCmdStr   = "nMissing command options.n";
  137. char *invalidCmdStr   = "nInvalid command or options.n";
  138. char *cmdOptionsAreStr   = "nAvailable command options:n";
  139. char *noSuchHistoryStr   = "nNo such history.n";
  140. char *badParamStr = "Bad param.n";
  141. char *operationFailedStr = "Operation failed.n";
  142. char *waitForAKeyStr  = "<Pause>n";
  143. char *Cli_FailedStr   = "Failed!n";
  146. static const char init_msg[] = "nPress [ENTER] key to active this console...";
  147. static const char banner1[] =
  148. "n"
  149. "+---------------------------------------+n"
  150. "| Net camera configuration console v1.2 |n"
  151. "|         GuangZhou Seeland Inc. 2005.5 |n"
  152. "+---------------------------------------+n";
  154. /* Telnet session state to track user login progress
  155.  */
  156. enum 
  157. {
  158. CLI_ACCESS_CMD_NULL,
  159. CLI_ACCESS_CMD_INIT,
  160. CLI_ACCESS_CMD_PROMPT_USER,
  161. CLI_ACCESS_CMD_PROMPT_PASS,
  162. CLI_ACCESS_CMD_OPEN
  163. };
  168. /* Command mode occupies 3 characters near the start of prompt
  169.  */
  170. static char *modePrompt[] = { "   ", "USR", "OPR", "ENG", "BLO" };
  171. #define   MODE_PROMPT_SIZE 3
  173. /* Available hardcoded usernames.
  174.  */
  175. #define   CLI_LOGIN_USER "user"
  176. #define   CLI_USER_PASSWORD  "eureka"  
  178. #define   CLI_LOGIN_OPERATOR   "super"
  179. #define   CLI_OPERATOR_PASSWORD "slxj530"
  181. #define   CLI_LOGIN_ENG  "eng"
  182. #define   CLI_LOGIN_ENG2 "engineer"
  183. #define   CLI_ENG_PASSWORD   "sierra"
  185. #define   CLI_LOGIN_BLO  "blo"
  186. #define   CLI_BLO_PASSWORD   "whatsup1226"
  189. #define   Is_space(c)  ((c) == ' ')
  193. /* Forward declaration of local static functions
  194.  */
  196. static Cli_CmdStruct_t *Cli_SeekOptionMatch(Cli_CmdStruct_t *baseCmdObj, 
  197. char *thisCmd, 
  198. int thisCmdLen);
  200. static void Cli_UpdateCmdHistory(Cli_cmdSession_t *pSess, char *cmdBuf, int len);
  202. static int Cli_Cmdprocessing(Cli_cmdSession_t *pSess, 
  203.  Cli_CmdStruct_t *baseCmdObj, 
  204.  char *cmdStr, 
  205.  int cmdPtr, 
  206.  int recurLevel);
  208. static int Cli_BuildCmdObj(Cli_CmdStruct_t **rootList, 
  209.    Cli_CmdStruct_t **workingList, 
  210.    unsigned int flags);
  212. static int Cli_SetAccessMode(Cli_cmdSession_t *pSess, int mode);
  214. static int Cli_VerifyPassword(Cli_cmdSession_t *pSess, char *cmdBuf, int len);
  216. static int Cli_ParseCmd(Cli_cmdSession_t *pSess, char *cmdBuf, int len);
  218. int Cli_PrepareOpenSession (Cli_cmdSession_t *pSess);
  221. #ifdef SC_PSOS
  222. #include <tmlib/AppSem.h>
  223. static struct _AppSem_Semaphore cli_mutex  = _AppSem_INITIALISED_SEM; 
  224. #define LOCKSESSION() AppSem_P( &cli_mutex );
  225. #define UNLOCKSESSION() AppSem_V( &cli_mutex);
  226. #else
  228. #include <pthread.h>
  229. static pthread_mutex_t cli_mutex = PTHREAD_MUTEX_INITIALIZER;
  230. #define LOCKSESSION() pthread_mutex_lock( &cli_mutex );
  231. #define UNLOCKSESSION() pthread_mutex_unlock( &cli_mutex);
  232. #endif
  235. /***************************************************************************** 
  236. * int Cli_WriteBuf(Cli_cmdSession_t *pSess, char *str, int len)
  237. *
  238. * Description :
  239. *   This function print a text string "str" of length "len".  The text string
  240. *   is not necessary to be NULL terminated.  It is important to get the length
  241. *   right.
  242. *
  243. *   This is the basic function that does ALL the CLI text output.  Modify this
  244. *   function to support multiple session type.
  245. * 
  246. * Arguments :
  247. *   pSess - a pointer to a command session
  248. *   str - a character string
  249. *   len - length of the character string.
  250. *
  251. * Returns :
  252. *   0 - OK
  253. *   -1 - Failed
  254. *
  255. * History
  256. *   who   when why
  257. *   KBL   9/7/99   created
  258. *
  259. *****************************************************************************/
  261. static int Cli_WriteBuf(Cli_cmdSession_t *pSess, char *str, int len)
  262. {
  263. char cr_buf[] = "rn";
  264. int idx, PrintLen;   
  265. char  *pStrStart;
  267. if (pSess->skipPrinting)
  268. return 0;
  270. pStrStart = NULL;
  271. for (idx = 0 ; idx < len; idx++) {
  272. int cr;
  273. if (pStrStart == NULL)
  274. pStrStart = &(str[idx]);
  276. /* If it's carriage return, perform end-of-line conversion. */
  277. cr = (str[idx] == 'n');
  278. if (cr || (idx == (len - 1))) {
  279. PrintLen = &(str[idx]) - pStrStart + 1;
  281. PrintLen -= cr;
  282. pSess->pSessFuns->write(pStrStart, PrintLen);
  283. if (cr)
  284. pSess->pSessFuns->write(cr_buf, 2);
  286. pStrStart = NULL; 
  287. pSess->pSessFuns->yield();
  288. }
  289. }
  290. return 0;
  291. }
  293. /***************************************************************************** 
  294. * void Cli_InitDataSet()
  295. *
  296. * Description :
  297. * This function must be called once during system initialization for proper
  298. * operation of the command line mechanism.
  299. * 
  300. * Arguments :
  301. * None
  302. *
  303. * Returns :
  304. * None
  305. *
  306. * History
  307. * who   when why
  308. * KBL   7/7/99   created
  309. *
  310. *****************************************************************************/
  311. static void Cli_InitDataSet()
  312. {
  313. int i;
  315. for (i = 0; i < NUM_OF_CLI_ACCESS_SESSION; i++) 
  316. sockSession[i].pSessFuns = NULL;
  317. return;
  318. }
  320. static Cli_cmdSession_t *
  321. Cli_NewSess () {
  322. int i;
  323. Cli_cmdSession_t *p = NULL;
  324. LOCKSESSION()
  325. for (i = 0; i < NUM_OF_CLI_ACCESS_SESSION; i++) {
  326. if (!sockSession[i].pSessFuns) {
  327. sockSession[i].pSessFuns = (Cli_SessionFuns_t*) 1;
  328. p = &sockSession[i];
  329. break;
  330. }
  331. }
  332. UNLOCKSESSION()
  333. return p;
  334. }
  336. static int Cli_FreeSess (Cli_cmdSession_t *pSess) {
  337. if (pSess->pSessFuns->cleanup)
  338. pSess->pSessFuns->cleanup(pSess);
  339. return 0;
  340. }
  342. /***************************************************************************** 
  343. * int Cli_CloseCmdSession(Cli_cmdSession_t *pSess)
  344. *
  345. * Description :
  346. * This function must be called when a command session is terminated so that
  347. * the session object associated with the obsolete session is freed.
  348. * 
  349. * Arguments :
  350. * the pointer to the command session
  351. *
  352. * Returns :
  353. * 0 if OK, -1 if failed.
  354. *
  355. * History
  356. * who   when why
  357. * KBL   7/7/99   created
  358. *
  359. *****************************************************************************/
  360. static int Cli_CloseCmdSession(Cli_cmdSession_t *pSess)
  361. {
  362. LOCKSESSION()
  363. Cli_FreeSess(pSess);
  365. /* set pSessFuns to NULL to "free" it */
  366. pSess->pSessFuns = NULL;
  367. UNLOCKSESSION()
  368. return 0;
  369. }
  371. /***************************************************************************** 
  372. * Cli_cmdSession_t Cli_InitCmdSession(int nsock)
  373. *
  374. * Description :
  375. * This function must be called before a specific telnet command session can
  376. * be used.  It is typical called after a successful accept operation.
  377. * 
  378. * Arguments :
  379. *   nsock - socket number returned by accept() or other equipvalent procedure.
  380. *
  381. * Returns :
  382. *   NULL if failed
  383. *   pointer to a command session if OK
  384. *
  385. * History
  386. * who   when why
  387. * KBL   7/7/99   created
  388. *
  389. *****************************************************************************/
  390. static Cli_cmdSession_t *
  391. Cli_InitCmdSession(Cli_SessionFuns_t *pSessFuns)
  392. {
  393. // int  i;
  394. Cli_cmdSession_t  *pSess;
  396. if ((pSess = Cli_NewSess()) == NULL)
  397. /* No more session space.  This should not happen */
  398. return NULL;
  400. if (pSessFuns->init)
  401. pSessFuns->init();
  403. bzero(pSess, sizeof(Cli_cmdSession_t));
  405. pSess->pSessFuns = pSessFuns;
  406. pSess->cmdSessionType = pSessFuns->sessionType;
  407. pSess->cmdState = CLI_ACCESS_CMD_NULL;
  408. pSess->historyNextNumber = 1;
  409. pSess->currentCmdMode = CLI_ACCESS_NO_MODE;
  410. pSess->myProductType = CLI_ACCESS_PRODUCT_1;
  411. pSess->pageLength = CLI_DEFAULT_PAGE_LENGTH;
  413. Cli_WriteBuf(pSess, (char*) init_msg, strlen(init_msg));
  414. return pSess;
  415. }
  417. /*****************************************************************************
  418. * 
  419. * Jcon_CLI_Task - 
  420. *    
  421. *    Jcon DP buffer dump and command line monitor task.
  422. *   
  423. * Description:   
  424. *    Upon starting, console input is read and checked against command list.
  425. *    Most important command functionality is DP buffer dump which 
  426. *    is specified in terms of number of lines before the end of the buffer.
  427. *    'quit' command closes all psos tasks and exits. This is strictly a debug
  428. *    workaround until both tmdbg.exe and Philips telnet Cli work reliably.
  429. *   
  430. * History:
  431. *   10/12/99 BM  Added header and Jim's code.
  432. *
  433. *****************************************************************************/
  435. static void*
  436. Jcon_CLI_Task(void *arg)
  437. {
  438. char   myChar;
  439. int ret; 
  440. Cli_SessionFuns_t *pSessFuns = (Cli_SessionFuns_t*)arg;
  442. /* Go straight into CLI now */
  443. while (1) {
  444. /* Initialize this command session.  Any nsock number will do
  445.  * for JTAG connection.
  446.  */
  447. Cli_cmdSession_t *pCli_Session = NULL;
  449. pCli_Session =  Cli_InitCmdSession(pSessFuns);
  451. if (pCli_Session == NULL)  {
  452. pSessFuns->log("****Can't initialize CLI****.n");
  453. break;
  454. }
  456. do {
  457. ret = pCli_Session->pSessFuns->read_char();
  458. if ( ret < 0) {
  459. break;
  460. }
  461. if ( !ret )
  462. pSessFuns->yield();
  463. myChar = ret;
  464. /* If session is closed, open another one. */
  465. } while (Cli_ProcessCmd(&myChar, 1, pCli_Session) != -1);
  466. Cli_CloseCmdSession(pCli_Session);
  467. }
  468. return NULL;
  469. }
  471. /************************************************************************
  472. *
  473. * Cli_Initialize - Initialize CLI for a JCON session.
  474. *
  475. * Returns:
  476. *   int - 0 if no error, nonzero otherwise.
  477. *
  478. * Description:
  479. *   Send an echo request to a host. Each TCP/IP stack seems to have 
  480. *   their own favorite API for this so we combine them here.
  481. *
  482. * Notes:
  483. *   None
  484. *
  485. * History:
  486. *   10/25/01 FD  Created.
  487. *
  488. ************************************************************************/
  490. int Cli_Initialize(Cli_SessionFuns_t *pSessFuns)
  491. {
  492. static char bInit = 1;
  493. unsigned long RetVal;
  495. /* Initialize CLI data set */
  496. if( bInit ) {
  497. bInit = 0;
  498. Cli_InitDataSet ();
  500. }
  501. /* Start JCON task now so we have CLI even if boot count suspends root */
  502. RetVal = pSessFuns->create_task("jcli", Jcon_CLI_Task, 0, 8192, (void*)pSessFuns);
  503. if (RetVal != 0)
  504. pSessFuns->log("ERROR: Jcon_CLI_Task(jcli) failed! status = %dn", RetVal);
  506. return (int) RetVal;
  507. }
  509. /***************************************************************************** 
  510. * void Cli_IncrementRowCounter(Cli_cmdSession_t *pSess)
  511. * void Cli_ResetRowCounter(Cli_cmdSession_t *pSess)
  512. * void Cli_DisableScrollPause(Cli_cmdSession_t *pSess)
  513. * void Cli_EnableScrollPause(Cli_cmdSession_t *pSess)
  514. * int Cli_SetPageLength(Cli_cmdSession_t *pSess, int NewPageLen)
  515. * int Cli_GetScrollPauseStatus(Cli_cmdSession_t *pSess, int *PageLen)
  516. *
  517. * Description :
  518. *   These functions control the pausing of scrolling.  
  519. * 
  520. * Arguments :
  521. *   pSess - the pointer to the command session
  522. *
  523. * Returns :
  524. *   0 if OK, -1 if failed.
  525. *
  526. * History
  527. *   who   when why
  528. *   KBL   7/7/99   created
  529. *
  530. *****************************************************************************/
  531. static void Cli_IncrementRowCounter(Cli_cmdSession_t *pSess)
  532. {
  533. pSess->currentRow++;
  534. }
  536. static void Cli_ResetRowCounter(Cli_cmdSession_t *pSess)
  537. {
  538. pSess->currentRow = 0;
  539. }
  541. void Cli_DisableScrollPause(Cli_cmdSession_t *pSess)
  542. {
  543. pSess->scrollPause = 0;
  544. }
  546. void Cli_EnableScrollPause(Cli_cmdSession_t *pSess)
  547. {
  548. pSess->scrollPause = 1;
  549. }
  551. int Cli_SetPageLength(Cli_cmdSession_t *pSess, int NewPageLen)
  552. {
  553. int OldLen;
  555. /* Keep a lower bound for page length. */
  556. if (NewPageLen < CLI_MINIMAL_PAGE_LENGTH) 
  557. {
  558. NewPageLen = CLI_MINIMAL_PAGE_LENGTH;
  559. }
  561. OldLen = pSess->pageLength;
  562. pSess->pageLength = NewPageLen;
  564. return 0;
  565. }
  567. int Cli_GetScrollPauseStatus(Cli_cmdSession_t *pSess, int *PageLen)
  568. {
  569. if (PageLen) 
  570. {
  571. *PageLen = pSess->pageLength;
  572. }
  573. return (pSess->scrollPause);
  574. }
  577. /***************************************************************************** 
  578. * int Cli_Prompt(Cli_cmdSession_t *pSess, int PromptStrOffset)
  579. *
  580. * Description :
  581. * This function prints the prompt with the proper history number embedded.
  582. * 
  583. * Arguments :
  584. * the pointer to the command session, and offset into the text string 
  585. * "prompt".  The offset thing is a cheap way to print either one or two
  586. * newlines.  The offset should never be larger than 2.
  587. *
  588. * Returns :
  589. * 0 if OK, -1 if failed.
  590. *
  591. * History
  592. * who   when why
  593. * KBL   7/7/99   created
  594. *
  595. *****************************************************************************/
  596. int Cli_Prompt(Cli_cmdSession_t *pSess, int PromptStrOffset)
  597. {
  598. /* Scrolling control can never span commands.  Therefore everytime we
  599.  * need to print the prompt, we reset row counter.
  600.  */
  601. Cli_ResetRowCounter(pSess);
  602. pSess->skipPrinting = 0;
  604. if (PromptStrOffset != 0)
  605. {
  606. Cli_Printf(pSess, "n") ;
  607. }
  608. return (Cli_Printf(pSess, "%s%d>", pSess->prompt, pSess->historyNextNumber));
  609. }
  612. /***************************************************************************** 
  613. * int Cli_ProcessCmd(char *msgbuf, int len, Cli_cmdSession_t *pSess)
  614. *
  615. * Description :
  616. * This function is called to pass in a message buffer from user input.  It
  617. * performs all the functionalities for proper command line interface including
  618. * user login, password validation, CR detection and subsequent command
  619. * processing, '?' character detectin and subsequent help processing and so
  620. * forth.
  621. *
  622. * Special notice : a char string containing the command is ALWAYS NULL
  623. *   terminated.  The length field is also passed in for
  624. *   convineance.
  625. * 
  626. * Arguments :
  627. * pointer to message buffer (msgbuf), its length (len) and pointer to session.
  628. *
  629. * Returns :
  630. * 0 if OK, -1 if bad.  A return of -1 must trigger a shutdown of this
  631. * socket.
  632. *
  633. * History
  634. * who   when why
  635. * KBL   7/7/99   created
  636. *
  637. *****************************************************************************/
  638. int Cli_ProcessCmd(char *msgbuf, int len, Cli_cmdSession_t *pSess)
  639. {
  640. int i, j, promptStrOffset;
  642. for (i = 0; i < len; i++) 
  643. {
  644. if (msgbuf[i] == 0x0A) 
  645. {
  646. /* ignore line feed (0x0A), Return (0x0D) is what we are looking for.  We
  647.  * will regenerate the combo LF/CR later.
  648.  */
  649. continue;
  650. }
  651. if (msgbuf[i] == 0x0D)
  652. {
  653. /* We can now process the CR/LF */
  654. switch (pSess->cmdState) 
  655. {
  656. case CLI_ACCESS_CMD_NULL:
  657. /* Add any special pre-loggin processing code here.  Otherwise
  658.  * it just go straight to getting user login.
  659.  */
  661. if (pSess->cmdSessionType == CLI_SERIAL_SESSION)
  662. {
  663. memcpy(pSess->myUserName, CLI_LOGIN_OPERATOR, strlen(CLI_LOGIN_OPERATOR));
  664. Cli_VerifyPassword(pSess, CLI_OPERATOR_PASSWORD, strlen(CLI_OPERATOR_PASSWORD));
  665. Cli_PrepareOpenSession(pSess);
  666. pSess->cmdState = CLI_ACCESS_CMD_OPEN;
  667. }
  668. else
  669. {
  670. pSess->cmdState = CLI_ACCESS_CMD_INIT;
  671. }
  672. break;
  674. case CLI_ACCESS_CMD_INIT:
  675. if (pSess->cmdBufIdx == 0) {
  676. /* user keep hitting Return */
  677. if (Cli_Printf((Cli_cmdSession_t*)pSess, "nusername:"))
  678. {
  679. return -1;
  680. }
  681. pSess->cmdState = CLI_ACCESS_CMD_PROMPT_USER;
  682. }
  683. break;
  685. case CLI_ACCESS_CMD_PROMPT_USER:
  686. /* Make sure the string is NULL terminated */
  687. pSess->cmdBuf[pSess->cmdBufIdx] = 0;
  689. if ( (pSess->cmdBufIdx == 0) || (pSess->cmdBufIdx > MAX_USERPASS_LEN) )
  690. {
  691. /* Damn user hit Return again */
  692. if (Cli_Printf((Cli_cmdSession_t*)pSess, "nusername:"))
  693. {
  694. return -1;
  695. }
  696. }
  697. else
  698. {  
  699. /* got username */
  700. memcpy(pSess->myUserName, pSess->cmdBuf, pSess->cmdBufIdx);
  701. Cli_SendCrLf(pSess);
  702. pSess->myUserName[pSess->cmdBufIdx] = 0;
  704. if (Cli_Printf((Cli_cmdSession_t *)pSess, "password:"))
  705. {
  706. return -1;
  707. }
  709. pSess->cmdState = CLI_ACCESS_CMD_PROMPT_PASS;
  710. }
  711. break;
  713. case CLI_ACCESS_CMD_PROMPT_PASS:
  714. /* Make sure the string is NULL terminated */
  715. pSess->cmdBuf[pSess->cmdBufIdx] = 0;
  716. Cli_SendCrLf(pSess);
  718. if ((pSess->cmdBufIdx > MAX_USERPASS_LEN) || 
  719. Cli_VerifyPassword(pSess, pSess->cmdBuf, pSess->cmdBufIdx) == -1)
  720. {
  721. if (Cli_Printf(pSess, badPasswordStr) < 0)
  722. {
  723. return -1;
  724. }
  725. pSess->cmdState = CLI_ACCESS_CMD_INIT;
  726. pSess->loginFailedCount++;
  728. /* Kick this user off if he/she keeps failing */
  729. if (pSess->loginFailedCount > MAX_LOGIN_FAILURE) 
  730. {
  731. return -1;
  732. }
  733. }
  734. else
  735. {
  736. pSess->cmdState = CLI_ACCESS_CMD_OPEN;
  737. if (Cli_PrepareOpenSession(pSess) != 0)
  738. {
  739. return -1;
  740. }
  741. }
  742. break;
  744. case CLI_ACCESS_CMD_OPEN:
  745. /* Make sure the string is NULL terminated */
  746. pSess->cmdBuf[pSess->cmdBufIdx] = 0;
  748. /* If user just hit CR then cmdBufIdx is 0.  In this case we don't
  749.  * print 2 LF.  Otherwise 2 LF is used.
  750.  */
  751. if(pSess->cmdBufIdx == 0)
  752. promptStrOffset = 1 ;
  753. else
  754. promptStrOffset = 0;
  756. /* copy the last command into history buffer as well; note that even
  757.  * bogus commands are copied.  Anything ended with a CR is a command.
  758.  */
  759. Cli_UpdateCmdHistory(pSess, pSess->cmdBuf, pSess->cmdBufIdx);
  761. if (Cli_ParseCmd(pSess, pSess->cmdBuf, pSess->cmdBufIdx) == -1)
  762. {
  763. Cli_Printf(pSess, endSessionStr);
  764. return -1;
  765. }
  768. if (Cli_Prompt(pSess, promptStrOffset) < 0)
  769. {
  770. return -1;
  771. }
  772. break;
  773. }
  775. /* Done processing last command, reset index */
  776. pSess->cmdBufIdx = 0;
  778. }
  779.    
  780. else if ((msgbuf[i] == 't') &&
  781.  (pSess->cmdState == CLI_ACCESS_CMD_OPEN))
  782. {
  783. pSess->cmdBuf[pSess->cmdBufIdx] = 't';
  784. pSess->cmdBufIdx++;
  785. pSess->cmdBuf[pSess->cmdBufIdx] = 0;
  787. if (Cli_Printf(pSess, "?") < 0) 
  788. {
  789. return -1;
  790. }
  792. Cli_UpdateCmdHistory(pSess, pSess->cmdBuf, pSess->cmdBufIdx);
  794. if ((j = Cli_ParseCmd(pSess, pSess->cmdBuf, pSess->cmdBufIdx)) == -1)
  795. {
  796. Cli_Printf(pSess, endSessionStr);
  797. return -1;
  798. }
  799. if (Cli_Prompt(pSess, 0) < 0)
  800. {
  801. return -1;
  802. }
  804. if (j != -2) 
  805. {
  806. /* now back out the '?' and print what user type */
  807. pSess->cmdBufIdx--;
  808. pSess->cmdBuf[pSess->cmdBufIdx] = 0;
  810. if (Cli_Printf(pSess, pSess->cmdBuf) < 0) 
  811. {
  812. return -1;
  813. }
  814. }
  815. else
  816. {
  817. /* try to get help on bogus command, reset command buffer */
  818. pSess->cmdBufIdx = 0;
  819. }
  820. }
  822. else
  823. {
  824. if (msgbuf[i] == 'b') 
  825. {
  826. /* If it's backspace, back cmdBufIdx up */
  827. if (pSess->cmdBufIdx > 0)
  828. {
  829. pSess->cmdBufIdx--;
  830. if (Cli_Printf(pSess, "b ") < 0)
  831. {
  832. return -1;
  833. }
  835. }
  836. else
  837. continue;
  838. }
  839. else
  840. {
  841. if ( pSess->cmdBufIdx >= (CLI_ACCESS_CMDSTR_SIZE - 2) ) 
  842. {
  843. if (pSess->cmdState == CLI_ACCESS_CMD_NULL)
  844. {
  845. pSess->cmdBufIdx = 0;
  846. }
  847. else
  848. {
  849. /* User has typed too much without hitting return or ?. 
  850.  * Don't copy into command buffer and don't echo it back.
  851.  */
  852. continue;
  853. }
  854. } 
  855. pSess->cmdBuf[pSess->cmdBufIdx] = msgbuf[i];
  856. pSess->cmdBufIdx++;
  857. }
  860. if ((pSess->cmdState != CLI_ACCESS_CMD_INIT) &&
  861. (pSess->cmdState != CLI_ACCESS_CMD_PROMPT_PASS))
  862. {
  863. if (Cli_PutChar(pSess, (msgbuf[i])) < 0)
  864. {
  865. return -1;
  866. }
  867. }
  868. }
  870. }
  871. return 0;
  872. }
  875. /*****************************************************************************
  876. * 
  877. * Cli_PrepareOpenSession - Displays session banner and initializes mode
  878. *
  879. * Returns:
  880. *   int - 0 on success, -1 on failure.
  881. *
  882. * Description:
  883. *   Called to prepare for entering session Open state after authenticating the
  884. *   user.
  885. *
  886. * History:
  887. *   12/19/99 MA  Original version
  888. *
  889. *****************************************************************************/
  890. int Cli_PrepareOpenSession (Cli_cmdSession_t *pSess)
  891. {
  892. int j;
  894. /* Print Philips logo */
  895. if (Cli_Printf(pSess,(char*) banner1) < 0)
  896. return -1;
  898. /* By default turn on scroll control. */
  899. Cli_EnableScrollPause(pSess);
  900. Cli_Printf(pSess, "Screen length is set to %d by default"
  901.   ", paging is enabled.n",
  902.    pSess->pageLength);
  904. if (Cli_Prompt(pSess, 0) < 0)
  905. {
  906. return -1;
  907. }
  908. return 0;
  909. }
  912. /***************************************************************************** 
  913. * static Cli_CmdStruct_t *Cli_SeekOptionMatch(Cli_CmdStruct_t *baseCmdObj, 
  914. *  char *thisCmd, 
  915. *  int thisCmdLen)
  916. *
  917. * Description :
  918. * This function scans the optionList of the supplied Cli_CmdStruct_t object to
  919. * find a match for the currently processed command/option.
  920. * 
  921. * Arguments :
  922. * pointer to the base Cli_CmdStruct_t object (baseCmdObj), currently processed 
  923. * command (thisCmd) and its length (thisCmdLen).
  924. *
  925. * Returns :
  926. * If a Cli_CmdStruct_t object is in optionList[] matches, it's pointer is
  927. * returned.  If no match, NULL is return.
  928. *
  929. * History
  930. * who   when why
  931. * KBL   7/7/99   created
  932. *
  933. *****************************************************************************/
  934. static Cli_CmdStruct_t *Cli_SeekOptionMatch(Cli_CmdStruct_t *baseCmdObj, 
  935. char *thisCmd, 
  936. int thisCmdLen)
  937. {
  938. int i;
  940. if (baseCmdObj->optionList == NULL) 
  941. {
  942. return NULL;
  943. }
  945. i = 0;
  946. while (baseCmdObj->optionList[i] != NULL)
  947. {
  948. if ( (strlen(baseCmdObj->optionList[i]->name) == (unsigned int) thisCmdLen) &&
  949.  !memcmp(baseCmdObj->optionList[i]->name, thisCmd, thisCmdLen)) 
  950. {
  951. return baseCmdObj->optionList[i];
  952. }
  953. i++;
  954. }
  955. return NULL;
  956. }
  959. /***************************************************************************** 
  960. * static int Cli_Cmdprocessing(Cli_cmdSession_t *pSess, 
  961. *   Cli_CmdStruct_t *baseCmdObj, 
  962. *   char *cmdStr, 
  963. *   int cmdPtr, 
  964. *   int recurLevel)
  965. *
  966. * Description :
  967. * This RECURSIVE function performs all help and command processing function.
  968. * To safeguard deep recursion, a maximum depth of 4 calls is enforced.
  969. * 
  970. * Arguments :
  971. * see it for yourself.
  972. *
  973. * Returns :
  974. * 0 if OK, -1 if failed.
  975. *
  976. * History
  977. * who   when why
  978. * KBL   7/7/99   created
  979. *
  980. *****************************************************************************/
  981. static int Cli_Cmdprocessing(Cli_cmdSession_t *pSess, 
  982.  Cli_CmdStruct_t *baseCmdObj, 
  983.  char *cmdStr, 
  984.  int cmdPtr, 
  985.  int recurLevel)
  986. {
  987. char  *thisCmd;
  988. int   i, thisCmdLen, oldCmdPtr;
  989. Cli_CmdStruct_t  *thisCmdObj;
  990. unsigned int  myAccessFlags;
  992. myAccessFlags = TO_ACCESS_FLAG(pSess->currentCmdMode) | 
  993. TO_ACCESS_FLAG(pSess->myProductType);
  995. if (recurLevel > 4) 
  996. {
  997. return 0;
  998. }
  999. recurLevel++;
  1001. oldCmdPtr = cmdPtr;
  1003. /* Find out the current command option and size */
  1004. thisCmd = cmdStr + cmdPtr;
  1005. thisCmdLen = 0;
  1006. for (i = cmdPtr; i < CLI_ACCESS_CMDSTR_SIZE; i++) 
  1007. {
  1008. if (Is_space(cmdStr[i]) || cmdStr[i] == 0)
  1009. {
  1010. thisCmdLen = i - cmdPtr;
  1011. break;
  1012. }
  1013. }
  1014. if (thisCmdLen <= 0)
  1015. {
  1016. /* no command or option at all, return */
  1017. return 0;
  1018. }
  1020. /* Have cmdPtr indexes the start of next options, or end of string */
  1021. for (i = cmdPtr + thisCmdLen; i < CLI_ACCESS_CMDSTR_SIZE; i++)
  1022. {
  1023. if (!Is_space(cmdStr[i]) || cmdStr[i] == 0) 
  1024. {
  1025. cmdPtr = i;
  1026. break;
  1027. }
  1028. }
  1030. /* Perform Help processing */
  1031. if (thisCmd[0] == 't') 
  1032. {
  1033. i = 0;
  1035. if (baseCmdObj->optionList == NULL) {
  1036. /* Without a optionList pointer, this is a leaf node.  There isn't
  1037.  * any other subcommands after this.
  1038.  */
  1039. if (baseCmdObj->helpStr != NULL) 
  1040. {
  1041. Cli_SendCrLf(pSess);
  1042. if (Cli_Printf(pSess, baseCmdObj->helpStr) < 0)
  1043. {
  1044. return -1;
  1045. }
  1046. Cli_SendCrLf(pSess);
  1047. }
  1048. else if (Cli_Printf(pSess, noHelpStr) < 0)
  1049. {
  1050. return -1;
  1051. }
  1052. } else {
  1053. int PrintVerbage = 1;
  1055. /* print out all available root level commands */
  1056. while (baseCmdObj->optionList[i] != NULL) 
  1057. {
  1059. if ((baseCmdObj->optionList[i]->accessFlag & myAccessFlags) == myAccessFlags)
  1060. {
  1061. if (PrintVerbage)
  1062. {
  1063. if (Cli_Printf(pSess, cmdOptionsAreStr) < 0)
  1064. {
  1065. return -1;
  1066. }
  1067. PrintVerbage = 0;
  1068. }
  1069.  
  1070. if (Cli_Printf(pSess, "   %-16s ", baseCmdObj->optionList[i]->name) < 0) 
  1071. {
  1072. return -1;
  1073. }
  1074. if (Cli_Printf(pSess, "%sn", baseCmdObj->optionList[i]->helpStr) < 0) 
  1075. {
  1076. return -1;
  1077. }
  1078. }
  1079. i++;
  1080. }
  1081. }
  1082. /* call additional help function if available */
  1083. if (baseCmdObj->helpFunc != NULL) 
  1084. return baseCmdObj->helpFunc(pSess, cmdStr, cmdPtr);
  1085. }
  1086. /* Perform command processing */
  1087. else
  1088. {
  1089. /* Look for the Cli_CmdStruct_t object which represents the command
  1090.  * option currently under processing.
  1091.  */
  1092. thisCmdObj = Cli_SeekOptionMatch(baseCmdObj, thisCmd, thisCmdLen);
  1093. if (thisCmdObj != NULL)
  1094. {
  1095. if ((cmdStr[cmdPtr] == 0) )
  1096. {
  1097. /* no more command options, or no optionList[], 
  1098.  * must execute handler.
  1099.  */
  1100. if ((thisCmdObj->procFunc != NULL) &&
  1101. ((thisCmdObj->accessFlag & myAccessFlags) == myAccessFlags))
  1102. {
  1103. if (Cli_Printf(pSess, "n") < 0)
  1104. {
  1105. return -1 ;
  1106. }
  1107. return thisCmdObj->procFunc(pSess, cmdStr, cmdPtr);
  1108. }
  1109. else
  1110. {
  1111. if (Cli_Printf(pSess, invalidCmdStr) < 0)
  1112. {
  1113. return -1;
  1114. }
  1115. return 0;
  1116. }
  1117. }
  1118. else
  1119. {
  1120. /* user has typed in some option, run Cli_Cmdprocessing() again.
  1121.  */
  1122. return Cli_Cmdprocessing(pSess, thisCmdObj, cmdStr, cmdPtr, recurLevel);
  1123. }
  1124. }
  1125. else
  1126. {
  1127. /* No match in optionList[].  There can be 2 reasons.
  1128.  * 1) user type in a bogus option.
  1129.  * 2) user type in a variable option.
  1130.  *
  1131.  * It is assumed that next higher (caller) cmdObj that supports
  1132.  * variable option will have a varOptFunc().  If no such handler
  1133.  * is defined, caller will determine that option is bogus.
  1134.  */
  1136. if ((baseCmdObj->varOptFunc != NULL) &&
  1137. ((baseCmdObj->accessFlag & myAccessFlags) == myAccessFlags))
  1138. {
  1139. if (Cli_Printf(pSess, "n") < 0)
  1140. {
  1141. return -1 ;
  1142. }
  1143. return baseCmdObj->varOptFunc(pSess, cmdStr, oldCmdPtr); //zouyx add
  1144. }
  1145. else
  1146. {
  1147. if (Cli_Printf(pSess, invalidCmdStr) < 0)
  1148. {
  1149. return -1;
  1150. }
  1151. }
  1152. return 0;
  1153. }
  1154. }
  1155. return 0;
  1156. }
  1159. /***************************************************************************** 
  1160. * static int Cli_BuildCmdObj(Cli_CmdStruct_t **rootList, 
  1161. * Cli_CmdStruct_t **workingList, 
  1162. * unsigned int accessflags)
  1163. *
  1164. * Description :
  1165. * This function is called to construct a working root command list based on
  1166. * the supplied accessFlags.
  1167. * 
  1168. * 
  1169. * Arguments :
  1170. * the root list (typical a list of all command), working list and the
  1171. * access flags.
  1172. *
  1173. * Returns :
  1174. * Always returns 0.
  1175. *
  1176. * History
  1177. * who   when why
  1178. * KBL   7/7/99   created
  1179. *
  1180. *****************************************************************************/
  1181. static int Cli_BuildCmdObj(Cli_CmdStruct_t **rootList, 
  1182.    Cli_CmdStruct_t **workingList, 
  1183.    unsigned int accessflags)
  1184. {
  1185. int i, j;
  1187. i = j = 0;
  1189. while(rootList[i] != NULL)
  1190. {
  1191. if (rootList[i]->accessFlag & accessflags)
  1192. {
  1193. workingList[j]=rootList[i];
  1194. j++;
  1195. }
  1196. i++;
  1197. }
  1199. return 0;
  1200. }
  1203. /***************************************************************************** 
  1204. * static int Cli_SetAccessMode(Cli_cmdSession_t *pSess, int mode)
  1205. *
  1206. * Description :
  1207. * This function must be called when user first login and enter/exit to
  1208. * different access level (e.g. go from operator to admin).  Based on
  1209. * current access mode, user access right and product type, a working list
  1210. * of commands is constructed.
  1211. * 
  1212. * Arguments :
  1213. * pointer to a session, plus access mode.
  1214. *
  1215. * Returns :
  1216. * Always returns 0.
  1217. *
  1218. * History
  1219. * who   when why
  1220. * KBL   7/7/99   created
  1221. *
  1222. *****************************************************************************/
  1223. static int Cli_SetAccessMode(Cli_cmdSession_t *pSess, int accessLevel)
  1224. {
  1225. // unsigned flags;
  1227. pSess->currentCmdMode = accessLevel;
  1228. sprintf(pSess->prompt, "[%s]", modePrompt[accessLevel]);
  1230. return 0;
  1231. }
  1233. /***************************************************************************** 
  1234. * static int Cli_VerifyPassword(Cli_cmdSession_t *pSess, char *password, int len)
  1235. *
  1236. * Description :
  1237. * This function verifies password against the current user of this session.
  1238. * More sophisticated method of verification should be used in the future.
  1239. * 
  1240. * Arguments :
  1241. * password string plus it's length.
  1242. *
  1243. * Returns :
  1244. * 0 if verified OK, -1 if failed.
  1245. *
  1246. * History
  1247. * who   when why
  1248. * KBL   7/7/99   created
  1249. *
  1250. *****************************************************************************/
  1251. static int Cli_VerifyPassword(Cli_cmdSession_t *pSess, char *password, int len)
  1252. {
  1253. /* These are the four level of access to CLI.  To make thing easy, it maps
  1254.  * to 4 unique username.  For example, if you log in as "Eng", you 
  1255.  * automatically have ENG level of access.
  1256.  */
  1257. char UserPassword[] = CLI_USER_PASSWORD;
  1258. char OperPassword[] = CLI_OPERATOR_PASSWORD;
  1259. char EngPassword[]  = CLI_ENG_PASSWORD;
  1260. char BloPassword[]  = CLI_BLO_PASSWORD;
  1262. int  AccessLevel;
  1263. char *DiffPassword;
  1265. if (!memcmp(pSess->myUserName, CLI_LOGIN_USER, strlen(CLI_LOGIN_USER)))
  1266. {
  1267. AccessLevel = CLI_ACCESS_USER_MODE;
  1268. DiffPassword = UserPassword;
  1269. }
  1270. else if (!memcmp(pSess->myUserName, CLI_LOGIN_OPERATOR, strlen(CLI_LOGIN_OPERATOR)))
  1271. {
  1272. AccessLevel = CLI_ACCESS_TECH_MODE;   /* operator = technican in my book */
  1273. DiffPassword = OperPassword;
  1274. }
  1275. else if ( (!memcmp(pSess->myUserName, CLI_LOGIN_ENG, strlen(CLI_LOGIN_ENG))) ||
  1276.   (!memcmp(pSess->myUserName, CLI_LOGIN_ENG2, strlen(CLI_LOGIN_ENG2))) )
  1277. {
  1278. AccessLevel = CLI_ACCESS_ENG_MODE;
  1279. DiffPassword = EngPassword;
  1280. }
  1281. else if (!memcmp(pSess->myUserName, CLI_LOGIN_BLO, strlen(CLI_LOGIN_BLO)))
  1282. {
  1283. AccessLevel = CLI_ACCESS_BLO_MODE;
  1284. DiffPassword = BloPassword;
  1285. }
  1286. else
  1287. {
  1288. /* Unknown user ! */
  1289. return -1;
  1290. }
  1292. if ( (( unsigned int) len == (strlen(DiffPassword))) && 
  1293.  (!memcmp(password, DiffPassword, strlen(DiffPassword))) )
  1294. {
  1295. Cli_SetAccessMode(pSess, AccessLevel);
  1296. return 0;
  1297. }
  1298. return -1;
  1299. }
  1302. /***************************************************************************** 
  1303. * static int Cli_ParseCmd(Cli_cmdSession_t *pSess, char *cmdBuf, int len)
  1304. *
  1305. * Description :
  1306. * This function is called when the session is in OPEN state (user successfully
  1307. * logged in) and a command has been entered (CR has been hit).  History (!...)
  1308. * processing is also performed here.
  1309. * 
  1310. * Arguments :
  1311. * Go take a look.
  1312. *
  1313. * Returns :
  1314. * 0 if OK, -1 if bad thing happened and the socket and session must be 
  1315. * terminated.
  1316. *
  1317. * History
  1318. * who   when why
  1319. * KBL   7/7/99   created
  1320. *
  1321. *****************************************************************************/
  1322. static int Cli_ParseCmd(Cli_cmdSession_t *pSess, char *cmdBuf, int len)
  1323. {
  1324. int hptr;
  1326. if (len)
  1327. {
  1328. if (cmdBuf[0] == '!') 
  1329. {
  1330. /* History processing */
  1331. Cli_SendCrLf(pSess);
  1332. if ((len == 2) && cmdBuf[1] == '!') 
  1333. {
  1334. hptr = (pSess->historyPtr + CLI_ACCESS_HISTORY_DEPTH - 1 )% CLI_ACCESS_HISTORY_DEPTH;
  1335. if (Cli_Printf(pSess, pSess->historyBuf[hptr]) < 0)
  1336. {
  1337. return -1;
  1338. }
  1339. }
  1340. else
  1341. {
  1342. int histNum;
  1344. /* Handle case of !XYZ where XYZ is the command history number */
  1345. if (sscanf(cmdBuf+1, "%d", &histNum) == 0)
  1346. {
  1347. if (Cli_Printf(pSess, invalidCmdStr) < 0)
  1348. {
  1349. return -1;
  1350. }
  1351. return 0;
  1352. }
  1353. else
  1354. {
  1355. for (hptr = 0; hptr < CLI_ACCESS_HISTORY_DEPTH; hptr++) 
  1356. {
  1357. if(pSess->historyNum[hptr] == histNum)
  1358. break;
  1359. }
  1361. /* Return if no such history is found */
  1362. if (hptr >= CLI_ACCESS_HISTORY_DEPTH) 
  1363. {
  1364. if (Cli_Printf(pSess, noSuchHistoryStr) < 0)
  1365. {
  1366. return -1;
  1367. }
  1368. return 0;
  1369. }
  1371. /* Print out the historical command */
  1372. if (Cli_Printf(pSess, pSess->historyBuf[hptr]) < 0)
  1373. {
  1374. return -1;
  1375. }
  1376. }
  1378. }
  1380. /* Record history and process the command as if user just type in the
  1381.  * same command rather than !XYZ
  1382.  */
  1383. Cli_UpdateCmdHistory(pSess, pSess->historyBuf[hptr], strlen(pSess->historyBuf[hptr]));
  1384. return Cli_Cmdprocessing(pSess, &Cli_WorkingRootCmdObj, pSess->historyBuf[hptr], 0, 0);
  1385. }
  1386. else
  1387. {
  1388. /* Command processing */
  1389. return Cli_Cmdprocessing(pSess, &Cli_WorkingRootCmdObj, cmdBuf, 0, 0);
  1390. }
  1391. }
  1392. return 0;
  1393. }
  1396. /***************************************************************************** 
  1397. * static void Cli_UpdateCmdHistory(Cli_cmdSession_t *pSess, 
  1398. *   char *cmdBuf, int len)
  1399. *
  1400. * Description :
  1401. * This function updates the last command into our ring buffer type command
  1402. * history buffer.
  1403. * 
  1404. * Arguments :
  1405. * the session, the command string and its length.
  1406. *
  1407. * Returns :
  1408. * None.
  1409. *
  1410. * History
  1411. * who   when why
  1412. * KBL   7/7/99   created
  1413. *
  1414. *****************************************************************************/
  1415. static void Cli_UpdateCmdHistory(Cli_cmdSession_t *pSess, char *cmdBuf, int len)
  1416. {
  1417. if (cmdBuf[0] == '!')
  1418. {
  1419. /* We don't record history commands */
  1420. return;
  1421. }
  1423. /* Copy the command into an entry in historyBuf[] and null terminated it */
  1424. memcpy(pSess->historyBuf[pSess->historyPtr], cmdBuf, len);
  1425. pSess->historyBuf[pSess->historyPtr][len] = 0;
  1426. pSess->historyNum[pSess->historyPtr] = pSess->historyNextNumber;
  1428. pSess->historyPtr = (pSess->historyPtr + 1) % CLI_ACCESS_HISTORY_DEPTH;
  1429. pSess->historyNextNumber++;
  1431. return;
  1432. }
  1435. /***************************************************************************** 
  1436. * int Cli_GetChar(Cli_cmdSession_t *pSess)
  1437. *
  1438. * Description :
  1439. *   This function blocks until a character is received unless the connection
  1440. *   is discontinued.
  1441. *
  1442. *   This is the basic function that does ALL the in-context CLI text input.
  1443. *   An in-context CLI text input is used when during processing of a command,
  1444. *   additional text input is needed.  Normally, text input to a CLI session is
  1445. *   via command processing handler.
  1446. *
  1447. *   Modify this function to support multiple session type.
  1448. * 
  1449. * Arguments :
  1450. *   pSess - a pointer to a command session
  1451. *
  1452. * Returns :
  1453. *   >= 0 - the character returned
  1454. *   -1 - Failed
  1455. *
  1456. * History
  1457. *   who   when why
  1458. *   KBL   11/17/99 created
  1459. *
  1460. *****************************************************************************/
  1462. int Cli_GetChar(Cli_cmdSession_t *pSess)
  1463. {
  1464. char MyChar;
  1466. while ((MyChar = pSess->pSessFuns->read_char()) == 0)
  1467. pSess->pSessFuns->yield();
  1468. return MyChar;
  1469. }
  1471. /*
  1472.  * CLI utility functions - based on Cli_PutStr()
  1473.  */
  1475. int Cli_PutStr(Cli_cmdSession_t *pSess, char *str, int len)
  1476. {
  1477. int  StrIdx, PrintLen;
  1478. char KeyPressed, *pStrStart;
  1480. pStrStart = NULL;
  1481. for (StrIdx = 0; StrIdx < len; StrIdx++) 
  1482. {
  1483. if (pStrStart == NULL)
  1484. {
  1485. pStrStart = &(str[StrIdx]);
  1486. }
  1488. if ((str[StrIdx] == 'n') || (StrIdx == (len - 1)))
  1489. {
  1490. PrintLen = &(str[StrIdx]) - pStrStart + 1;
  1492. Cli_WriteBuf(pSess, pStrStart, PrintLen);
  1494. pStrStart = NULL;
  1496. if ((str[StrIdx] == 'n') && pSess->scrollPause) 
  1497. {
  1498. pSess->currentRow++;
  1500. if (pSess->currentRow >= (pSess->pageLength - 1)) 
  1501. {
  1502. Cli_WriteBuf(pSess, waitForAKeyStr, strlen(waitForAKeyStr));
  1504. KeyPressed = Cli_GetChar(pSess);
  1506. /* Clear out the "Press XYZ..." string. */
  1507. /* Cli_Printf(pSess, " r"); */
  1509. /* Check for ESC */
  1510. if (KeyPressed == 0x1b)
  1511. {
  1512. pSess->skipPrinting = 1;
  1513. break;
  1514. }
  1516. /* Check for -1 */
  1517. if (KeyPressed == -1)
  1518. {
  1519. return -1;
  1520. }
  1521. /* Don't forget to reset the row counter ! */
  1522. Cli_ResetRowCounter(pSess);
  1523. }
  1524. }
  1525. }   
  1527. }
  1528. return 0;
  1529. }
  1532. /***************************************************************************** 
  1533. * int Cli_Printf(Cli_cmdSession_t *pSess, char *fmt, ...)
  1534. *
  1535. * Description :
  1536. * This is the printf function for CLI.
  1537. * 
  1538. * Arguments :
  1539. * pCmdSession - opaque pointer to a command session
  1540. * the rest of the parameters are the same as for printf().
  1541. *
  1542. * Returns :
  1543. *   0 - OK
  1544. *   
  1545. *
  1546. * History
  1547. * who   when why
  1548. * KBL   7/7/99   created
  1549. *
  1550. *****************************************************************************/
  1551. int Cli_Printf(Cli_cmdSession_t *pSess, char *fmt, ...)
  1552. {
  1553. va_list  ap;
  1555. va_start(ap, fmt);
  1556. vsprintf(pSess->scratchBuf, fmt, ap);
  1557. va_end(ap);
  1559. /* Make sure it's NULL terminated at the very least */
  1560. pSess->scratchBuf[SCRATCH_BUF_SIZE-2] = 0;
  1562. return Cli_PutStr(pSess, pSess->scratchBuf, strlen(pSess->scratchBuf)); 
  1563. }
  1566. /***************************************************************************** 
  1567. * int Cli_PutChar(Cli_cmdSession_t *pSess, char ch)
  1568. *
  1569. * Description :
  1570. * This function print a character.
  1571. * 
  1572. * Arguments :
  1573. * pCmdSession - opaque pointer to a command session
  1574. * ch - the character.
  1575. *
  1576. * Returns :
  1577. *   0 - OK
  1578. *  -1 - Failed
  1579. *
  1580. * History
  1581. * who   when why
  1582. * KBL   9/7/99   created
  1583. *
  1584. *****************************************************************************/
  1585. int Cli_PutChar(Cli_cmdSession_t *pSess, char ch)
  1586. {
  1587. return Cli_PutStr(pSess, &ch, 1);
  1588. }
  1591. /***************************************************************************** 
  1592. * int Cli_SendCrLf(Cli_cmdSession_t *pSess)
  1593. *
  1594. * Description :
  1595. * send a CR/LF pair to advance a line.
  1596. * 
  1597. * Arguments :
  1598. *   pSess - pointer to the session.
  1599. *
  1600. * Returns :
  1601. *   0 if OK
  1602. *   -1 if Failed, likely cause is a bad socket.
  1603. *
  1604. * History
  1605. * who   when why
  1606. * KBL   7/7/99   created
  1607. *
  1608. *****************************************************************************/
  1609. int Cli_SendCrLf(Cli_cmdSession_t *pSess)
  1610. {
  1611. return ( Cli_Printf(pSess, "n") );
  1612. }
  1615. /***************************************************************************** 
  1616. * int Cli_PrintLine(Cli_cmdSession_t *pSess, 
  1617. *    int  NumChar,
  1618. *    char Character,
  1619. *    int  NumFrontCR, 
  1620. *    int  NumBackCR)
  1621. *
  1622. * Description :
  1623. *   This function draws a line made up of "Character" of "NumChar" width.
  1624. *   If "NumFrontCR" is 1, a CR is placed before the line.  Likewise if
  1625. *   "NumBackCR" is 1, a CR is placed after the line.
  1626. * 
  1627. * Arguments :
  1628. *   pSess - pointer to the session.
  1629. *   see above for explantion for the other parameters.
  1630. *
  1631. * Returns :
  1632. *   0 if OK
  1633. *   -1 if Failed, likely cause is a bad socket.
  1634. *
  1635. * History
  1636. * who   when why
  1637. * KBL   7/7/99   created
  1638. *
  1639. *****************************************************************************/
  1640. int Cli_PrintLine(Cli_cmdSession_t *pSess, 
  1641.  int  NumChar,
  1642.  char Character,
  1643.  int  NumFrontCR, 
  1644.  int  NumBackCR)
  1645. {
  1646. int Cnt;
  1648. for (Cnt = 0; Cnt < NumFrontCR; Cnt++) 
  1649. {
  1650. if (Cli_SendCrLf(pSess) == -1) return -1;
  1651. }
  1653. for (Cnt = 0; Cnt < NumChar; Cnt++) 
  1654. {
  1655. if (Cli_Printf(pSess, "%c", Character) == -1) return -1;
  1656. }
  1658. for (Cnt = 0; Cnt < NumBackCR; Cnt++) 
  1659. {
  1660. if (Cli_SendCrLf(pSess) == -1) return -1;
  1661. }
  1663. return 0;
  1664. }
  1667. /***************************************************************************** 
  1668. * int Cli_PrintFileContent(Cli_cmdSession_t *pSess, char *FileName)
  1669. *
  1670. * Description :
  1671. *   This function prints out the content of a file.  The file must better be
  1672. *   a text file, otherwise weird thing may happen.
  1673. * 
  1674. * Arguments :
  1675. *   pSess - pointer to the session.
  1676. *   FileName - pointer to a filename string.
  1677. *
  1678. * Returns :
  1679. *   0 if OK
  1680. *   -1 if Failed, likely cause is a bad socket.
  1681. *
  1682. * History
  1683. *   who   when why
  1684. *   KBL   11/24/99 created
  1685. *
  1686. *****************************************************************************/
  1687. int Cli_PrintFileContent(Cli_cmdSession_t *pSess, char *FileName)
  1688. {
  1689. FILE *fp;
  1690. char ScratchPadStr[100];
  1692. if ((fp = fopen(FileName, "rt")) == NULL) 
  1693. {
  1694. Cli_Printf(pSess, "Could not open file %sn", FileName);
  1695. return 0;
  1696. }
  1698. Cli_SendCrLf(pSess);
  1699. Cli_SendCrLf(pSess);
  1701. Cli_Printf(pSess, "%s :n", FileName);
  1703. while (fgets(ScratchPadStr, (sizeof(ScratchPadStr) - 1), fp) != NULL ) 
  1704. {
  1705. if (Cli_Printf(pSess, "%s", ScratchPadStr) != 0)
  1706. {
  1707. fclose(fp);
  1708. return -1;
  1709. }
  1710. }
  1712. fclose(fp);
  1714. return 0;
  1715. }
  1719. /*+***************************************************************************
  1720. * 
  1721. * Cli_PrintData - Utility function for dumping memory
  1722. *
  1723. * Returns:
  1724. *   void- 
  1725. *
  1726. * Description:
  1727. *   Formats for display the contents of a memory buffer. The eFormat option
  1728. *   indicates the data width and representation (dec, hex). The bUseRelativeAddr
  1729. *   parameter determines whether a zero-based index is displayed or the absolute
  1730. *   address of the data at the start of each line.
  1731. *
  1732. * History:
  1733. *   1/13/00  MA  Original version
  1734. *
  1735. **-**************************************************************************/ 
  1736. void Cli_PrintData(Cli_cmdSession_t *pSess, void *pvBuffer, int nBytes, 
  1737.    Cli_PrintFormat_e eFormat, int bUseRelativeAddr)
  1738. {
  1739. int i, j;
  1740. int LineLen;
  1741. char Char;
  1742. int iChar;
  1744. if (eFormat == CLI_PRINT_DATA_FORMAT_HEX8)
  1745. {
  1746. LineLen = 16;
  1747. }
  1748. else if (eFormat <= CLI_PRINT_DATA_FORMAT_HEX32)
  1749. {
  1750. LineLen = 4;
  1751. }
  1752. else
  1753. {
  1754. LineLen = 8;
  1755. }
  1757. for (i = 0; i < nBytes;)
  1758. {
  1759. if (bUseRelativeAddr)
  1760. Cli_Printf(pSess, "0x%04x: ", i);
  1761. else
  1762. Cli_Printf(pSess, "0x%08x: ", (u_int32_t)pvBuffer + i);
  1764. /* Save start offset of line */
  1765. iChar = i;
  1766. for (j = 0; j < LineLen && i < nBytes; j++)
  1767. {
  1768. switch (eFormat)
  1769. {
  1770. case CLI_PRINT_DATA_FORMAT_INT32:
  1771. Cli_Printf(pSess, "%11d ", *((int *)((u_int32_t)pvBuffer + i)));
  1772. i += sizeof(int);
  1773. break;
  1775. case CLI_PRINT_DATA_FORMAT_UINT32:
  1776. Cli_Printf(pSess, "%10lu ", *((unsigned int *)((u_int32_t)pvBuffer + i)));
  1777. i += sizeof(int);
  1778. break;
  1780. case CLI_PRINT_DATA_FORMAT_INT16:
  1781. Cli_Printf(pSess, "%6d ", (int) *((int16_t *)((u_int32_t)pvBuffer + i)));
  1782. i += sizeof(int16_t);
  1783. break;
  1785. case CLI_PRINT_DATA_FORMAT_UINT16:
  1786. Cli_Printf(pSess, "%5lu ", (unsigned int) *((u_int16_t *)((u_int32_t)pvBuffer + i)));
  1787. i += sizeof(int16_t);
  1788. break;
  1790. case CLI_PRINT_DATA_FORMAT_INT8:
  1791. Cli_Printf(pSess, "%4d ", (int) *((int8_t *)((u_int32_t)pvBuffer + i)));
  1792. i += sizeof(int8_t);
  1793. break;
  1795. case CLI_PRINT_DATA_FORMAT_UINT8:
  1796. Cli_Printf(pSess, "%3d ", (unsigned int) *((u_int8_t *)((u_int32_t)pvBuffer + i)));
  1797. i += sizeof(int8_t);
  1798. break;
  1800. case CLI_PRINT_DATA_FORMAT_HEX32:
  1801. Cli_Printf(pSess, "%08x ", *((u_int32_t *)((u_int32_t)pvBuffer + i)));
  1802. i += sizeof(u_int32_t);
  1803. break;
  1805. case CLI_PRINT_DATA_FORMAT_HEX16:
  1806. Cli_Printf(pSess, "%04x ", (u_int32_t) *((u_int16_t *)((u_int32_t)pvBuffer + i)));
  1807. i += sizeof(u_int16_t);
  1808. break;
  1810. default:
  1811. case CLI_PRINT_DATA_FORMAT_HEX8:
  1812. Cli_Printf(pSess, "%02x ", (u_int32_t) *((u_int8_t *)((u_int32_t)pvBuffer + i)));
  1813. i += sizeof(u_int8_t);
  1814. break;
  1815. }
  1817. }
  1819. if (eFormat == CLI_PRINT_DATA_FORMAT_HEX8)
  1820. {
  1821. /* Align to start of text column */
  1822. for (;j < LineLen + 1; j++)
  1823. {
  1824. Cli_Printf(pSess, "   ");
  1825. }
  1827. /* Now print ASCII representation of this line */
  1828. for (j = 0; j < LineLen && iChar < nBytes; j++, iChar++)
  1829. {
  1830. Char = *(char *)((u_int32_t)pvBuffer + iChar);
  1831. if (!isprint(Char))
  1832. Char = '.';
  1833. Cli_Printf(pSess, "%c", Char);
  1834. }
  1835. }
  1837. Cli_Printf(pSess, "n");
  1838. }
  1839. }
  1842. /***************************************************************************** 
  1843. * int Cli_IpAndMask2int()
  1844. *
  1845. * Description :
  1846. * convert from a string like "A.B.C.D/P.Q.R.S" to its IP address and mask
  1847. * in unsigned int.
  1848. * 
  1849. * Arguments :
  1850. * str is where the string start, the values are returned via addr and mask.
  1851. *
  1852. * Returns :
  1853. * 0 if OK, -1 if convertion error.  Both addr & mask are returned in network
  1854. * byte order.
  1855. *
  1856. * History
  1857. * who   when why
  1858. * KBL   7/15/99  created
  1859. *
  1860. *****************************************************************************/
  1861. int Cli_IpAndMask2int(char *str, unsigned int *addr, unsigned int *mask)
  1862. {
  1863. int    iByte, value;
  1864. unsigned int  ipaddress = 0;
  1865. unsigned int  ipmask = 0;
  1866. char   *pb, *pb2;
  1868. pb = str;
  1869. pb2 = strchr(pb, '/') + 1;  /* knows where the mask is before messing up */
  1871. /* Parse dotted IP address */
  1872. for (iByte = 0; iByte < 4; iByte++)
  1873. {
  1874. value = atoi(pb);
  1875. if (value > 255)
  1876. {
  1877. return -1;
  1878. }
  1880. ipaddress |= (value << 24);
  1881. if (iByte < 3) 
  1882. {
  1883. ipaddress >>= 8;
  1885. pb = strchr (pb, '.');
  1886. if (pb == NULL)
  1887. {
  1888. return -1;
  1889. }
  1890. pb++;  /* move to the number field */
  1891. }
  1892. }
  1894. /* If the caller only need IP address, mask is NULL, we return here. */
  1895. if (mask == NULL) 
  1896. {
  1897. *addr = ipaddress;
  1898. return 0;
  1899. }
  1901. /* make sure the next "." is after "/" */
  1902. pb = strchr(pb, '.');
  1903. if ((pb == NULL) || (pb < pb2))
  1904. {
  1905. return -1;
  1906. }
  1908. /* Parse dotted IP mask */
  1909. for (iByte = 0; iByte < 4; iByte++)
  1910. {
  1911. value = atoi(pb2);
  1912. if (value > 255)
  1913. {
  1914. return -1;
  1915. }
  1916. ipmask |= (value << 24);
  1917. if (iByte < 3)
  1918. {
  1919. ipmask >>= 8;
  1921. pb2 = strchr (pb2, '.');
  1922. if (pb2 == NULL)
  1923. {
  1924. return -1;
  1925. }
  1926. pb2++;
  1927. }
  1928. }
  1930. /* make sure there is no more "." */
  1931. pb2 = strchr(pb2, '.');
  1932. if (pb2 != NULL) 
  1933. {
  1934. return -1;
  1935. }
  1937. *addr = ipaddress;
  1938. *mask = ipmask;
  1939. return 0;
  1940. }