tstsh.c

ertfs文件系统里面既有完整ucos程序

/**************************************************************************
    TSTSH.C   - Command driven test shell for embedded file manager.
                       
Summary
    TSTSH

 Description
    Interactive shell program designed to allow testing of the file manager.
    Commands are:

    BRA V1 < = ! < > > V2 LABEL 
    CAT PATH 
    CD PATH or CD to display PWD  
    CHSIZE FILENAME newsize
    CLOSE FDNO 
    COPY PATH PATH 
    DELETE PATH 
    DELTREE PATH
    DIFF PATH PATH 
    DIR PATH 
    DSKOPEN:  D: 
    DSKSEL    D: 
    ECHO: [args] 
    FILLFILE PATH PATTERN NTIMES 
    FORMAT (routine will prompt for arguments)
    HELP:
    LOAD [FILENAME] 
    LSTOPEN (lists all open file decscriptors)  
    MKDIR PATH 
    MKFS E: 
    OP V1 <+,*,-,/,%> V2 DEST <A-Z> 
    QUIET ON,OFF 
    QUIT 
    READ FDNO 
    RENAME PATH NEWNAME 
    STAT   PATH
    FSTAT  PATH
    RMDIR PATH 
    RNDOP PATH RECLEN 
    RUN
    SEEK FDNO RECORD 
    SET <A-Z> VALUE 
    SETATTR D:PATH RDONLY|HIDDEN|SYSTEM|ARCHIVE|NORMAL
    WRITE FDNO QUOTED DATA 

Returns

Example:
*****************************************************************************
*/

#if (defined(ERTFS_SA))
#include <pcdisk.h>
#else
/* load RTIP configuration settings */
#include "xnconf.h"
#include "drvconf.h"
#include <rtfsapi.h>
#include "demo.h"
#define tm_printf_2(X,Y) tm_printf(X,Y)
#define tm_printf_3(X,Y,Z) tm_printf(X,Y,Z)
#endif


// 10-24-2000 added LBA formatting. Submit to main tree

// Set to one to compile in check disk. 
#define INCLUDE_CHKDSK 1
#if (INCLUDE_PCMCIA)
void  KS_FAR mgmt_isr(int arg);
#endif

#if (!defined(ERTFS_SA))
#include "demo.h"
#define tm_printf_2(X,Y) tm_printf(X,Y)
#define tm_printf_3(X,Y,Z) tm_printf(X,Y,Z)
#endif

unsigned char shell_buf[1024];
char working_buf[100];      // used by lex: must be global

typedef struct prg_line
{
    struct prg_line *pnext_line;
    int  label;
    char command[1];
} PRGLINE;


typedef struct dispatcher {
    char *cmd;
    int  (*proc)( int argc, char **argv);
    char *helpstr;
} DISPATCHER;

typedef struct rndfile {
    PCFD fd;
    int reclen;
    char name[45];
    char buff[512];
} RNDFILE;

#define MAXRND 10

RNDFILE rnds[MAXRND];

DISPATCHER *lex(int *agc, char **agv, char *input);
char *gnext(char *p);
int echo( int agc, char **agv);
int doquit(int agc, char **agv);
int dopcmcia(int agc, char **agv);
RNDFILE *fndrnd( PCFD fd);
int doeject(int agc, char **agv);
int dohelp(int agc, char **agv);
int dodskop(int agc, char **agv);
int dodskcl(int agc, char **agv);
int doselect(int agc, char **agv);
int rndop(int agc, char **agv);
int doclose(int agc, char **agv);
int doseek(int agc, char **agv);
int doread(int agc, char **agv);
int dowrite(int agc, char **agv);
int dolstop(int agc, char **agv);
int domkdir(int agc, char **agv);
int dormdir(int agc, char **agv);
int dorm(int agc, char **agv);
int dodeltree(int agc, char **agv);
int domv(int agc, char **agv);
int docwd(int agc, char **agv);
int dols(int agc, char **agv);
int pc_seedir(char *path);
int docat(int agc, char **agv);
int dochsize(int agc, char **agv);
#if (INCLUDE_CHKDSK)
int dochkdsk(int agc, char **agv);
#endif
int docopy(int agc, char **agv);
int dodiff(int agc, char **agv);
int domkfs(int agc, char **agv);
int dofillfile(int agc, char **agv);
int dostat(int agc, char **agv);
int dogetattr(int agc, char **agv);
int dosetattr(int agc, char **agv);
int doformat(int agc, char **agv);
#if (FAT32)
int domkfat32(int agc, char **agv);
#endif
BOOLEAN pc_gets(int fd, char *buf);
int compare(char *constant, char *buffer);
void int_tostring(long num, char *dest);


#if (USE_CDFS)
#include <cdfs.h>
int cddodskop(int agc, char **agv);
int cddodskcl(int agc, char **agv);
int cddoselect(int agc, char **agv);
int cddocwd(int agc, char **agv);
int cddols(int agc, char **agv);
int cddocat(int agc, char **agv);
//int cddocopy(int agc, char **agv);
//int cddoread(int agc, char **agv);
#endif

DISPATCHER cmds[] = 
    {
    { "", dohelp, ""},
    { "CAT", docat,"CAT PATH" },
    { "CHSIZE", dochsize, "CHSIZE FILENAME NEWSIZE"},
    { "CD", docwd, "CD PATH or CD to display PWD " },
#if (USE_CDFS)
    { "CDCAT", cddocat,"CDCAT PATH" },
//    { "CDCOPY", cddocopy,"CDCOPY PATH PATH" },
//    { "CDREAD", cddoread,"CDREAD PATH" },
    { "CDCD", cddocwd, "CDCD PATH " },
    { "CDDIR", cddols, "CDDIR PATH" },
    { "CDDSKCLOSE", cddodskcl, "CDDSKCLOSE: D:" },
    { "CDDSKOPEN", cddodskop, "CDDSKOPEN: D:" },
    { "CDDSKSEL", cddoselect, "CDDSKSEL D:" },
#endif
#if (INCLUDE_CHKDSK)
    { "CHKDSK", dochkdsk, "CHKDSK D: <0,1> 1 is write lost chains"},
#endif
    { "CLOSE", doclose, "CLOSE FDNO" },
    { "COPY", docopy,"COPY PATH PATH" },
    { "DELETE",dorm, "DELETE PATH" },
    { "DELTREE", dodeltree, "DELTREE PATH"},
    { "DIFF", dodiff,"DIFF PATH PATH" },
    { "DIR", dols, "DIR PATH" },
    { "DSKSEL", doselect, "DSKSEL D:" },
    { "ECHO", echo, "ECHO: [args]" },
    { "EJECT", doeject, "EJECT (ejects LS-120)" },
    { "FILLFILE", dofillfile,"FILLFILE PATH PATTERN NTIMES"},
    { "FORMAT", doformat,"FORMAT (routine will prompt for arguments)"},
    { "GETATTR", dogetattr,"GETATTR FILE"},
    { "HELP", dohelp, "HELP:" },
    { "LSTOPEN", dolstop, "LSTOPEN (lists all open file decscriptors) "  },
    { "MKDIR", domkdir, "MKDIR PATH" },
    { "PCMCIAINT",  dopcmcia, "PCMCIAINT (Force a PCMCIA mgmt Interrupt)" },
    { "QUIT", doquit, "QUIT" },
    { "READ",  doread, "READ FDNO" },
    { "RENAME",domv, "RENAME PATH NEWNAME" },
    { "RMDIR", dormdir, "RMDIR PATH" },
    { "RNDOP", rndop, "RNDOP PATH RECLEN" },
    { "SEEK",  doseek, "SEEK FDNO RECORD" },
    { "SETATTR", dosetattr, "SETATTR D:PATH RDONLY|HIDDEN|SYSTEM|ARCHIVE|NORMAL"},
    { "STAT", dostat, "STAT PATH" },
    { "WRITE", dowrite, "WRITE FDNO QUOTED DATA" },
    { 0 }
    };


char *gnext(char *p);
void exit(int);

word host_disk_size = 512;      /* If we format a host disk make it 256 K */

// ********************************************************************
// THIS IS THE MAIN PROGRAM FOR THE TEST SHELL
// ********************************************************************
void  tst_shell(void)                             /* __fn__ */
{
    DISPATCHER *pcmd;
    int  agc = 0;
    char *agv[20];
    int i;
    char buffer[32];

    tc_memset((PFBYTE)rnds, 0, sizeof(RNDFILE)*MAXRND);

    for (i = 0 ; i < MAXRND; i++)
        rnds[i].fd = -1;
#if (USE_CDFS)
    if (!cd_memory_init())
    {
        tm_printf("CD Memory init failed\n");
    }
#endif 
    dohelp(agc, agv);

    pcmd = lex( &agc, &agv[0], 0);
    while (pcmd)
    {
        i = pcmd->proc(agc, &agv[0]);
        int_tostring((long) i, buffer);
        pcmd = lex( &agc, &agv[0], 0);
   }
}

// ********************************************************************
// get next command; process history log
void do_prompt(char *working_buf)
{

#if (EBSENV)
#if (!RTFS_SA)
    aos_stop_console_tasks();
#endif
#endif

    working_buf[0] = 0;
    tm_printf(">: ");
    tm_gets(working_buf);
    tm_printf("\n");
#if (EBSENV)
#if (!RTFS_SA)
    aos_resume_console_tasks();
#endif
#endif


}

DISPATCHER *lex(int *agc, char **agv, char *input)      /*__fn__*/
{
    char *cmd,*p;
    DISPATCHER *pcmds = &cmds[0]; 

    *agc = 0;    
    if (input)
    {
        tc_strcpy(working_buf, input);
    }
    else
    {
        do_prompt(working_buf);
    }
//  pc_str2upper(working_buf, working_buf);
    p = cmd = &working_buf[0];

    p = gnext(p);

    while (p)
    {
       if (*p == '"')
           *agv++ = (p+1);
       else
           *agv++ = p;
       *agc += 1;
        p = gnext(p);
    }
    pc_str2upper(cmd, cmd);

    while (pcmds->cmd)
    {
        if (tc_strcmp(pcmds->cmd,cmd) == 0)
            return (pcmds);
        pcmds++;
    }

    /* No match return ??? */
    return (&cmds[0]);
 }

/* Null term the current token and return a pointer to the next */
char *gnext(char *p)                                            /*__fn__*/
{
    char termat;

    /* Look for space or the end of a quoted string */
    if (*p == '"')
        termat = '"';
    else
        termat = ' ';

    p++;
    while (*p)
    {
        if (*p == termat)
        {
            *p++ = '\0';    /* Null it and look at next */
            break;
        }
        p++;
    }

    if (!*p)                /* All done */
        p = 0;

    return (p);
}

int echo( int agc, char **agv)                                  /*__fn__*/
{
    int i;
    for (i = 0; i < agc; i++)
        tm_printf_2(":%s:\n",*agv++);
    return (1);
}

int doquit( int agc, char **agv)                                /*__fn__*/
{
    ARGSUSED_INT(agc);
    ARGSUSED_PVOID((PFVOID)agv);
    /* Release all resources used by the disk the disk */
    aos_exit();
    return (1);
}

int dopcmcia( int agc, char **agv)                                /*__fn__*/
{
    ARGSUSED_INT(agc);
    ARGSUSED_PVOID((PFVOID)agv);
#if (INCLUDE_PCMCIA)
    mgmt_isr(0);
#endif
    /* Release all resources used by the disk the disk */
    return (1);
}


/* Given a fd. return a RNDFILE record with matching fd */
RNDFILE *fndrnd( PCFD fd)                                       /*__fn__*/
{
int i;

    for (i = 0 ; i < MAXRND; i++)
    {
        if (fd == rnds[i].fd)
            return (&rnds[i]);
    }
    return (0);
}

int dohelp(int agc, char **agv)                             /*__fn__*/
{
DISPATCHER *pcmds = &cmds[0]; 
char buf[10];
int nprinted = 0;

    ARGSUSED_INT(agc);
    ARGSUSED_PVOID((PFVOID)agv);

    while (pcmds->cmd)
    {
        tm_printf_2("%s\n", pcmds->helpstr);
        if (nprinted++ > 20)
        {
            tm_printf("Press any key");
            tm_gets(buf);
            tm_printf("\n");
            nprinted = 0;
        }
        pcmds++;
    }
    return (1);
}

/* EJECT D: */ 
BOOLEAN ide_eject_media(int driveno);

int doeject(int agc, char **agv)                                   /*__fn__*/
{
    ARGSUSED_INT(agc);
#if (USE_ATA)
    if (!ide_eject_media((int)(**agv-'A')))
        tm_printf("?\n");
#endif
    return(0);
}



/* DSKSEL PATH */ 
int doselect(int agc, char **agv)                                   /*__fn__*/
{
    if (agc == 1)
    {
        if (!pc_setdfltdrvno((int)(**agv-'A')))
        {
            tm_printf("?\n");
            return(0);
        }
        return(1);
    }
    else 
    {
         tm_printf("Usage: DSKSELECT D: \n");
         return(0);
    }
}


/* RNDOP PATH RECLEN */ 
int rndop(int agc, char **agv)                                  /*__fn__*/
{
    RNDFILE *rndf;

    if (agc == 2)
    {
        rndf = fndrnd( -1);
        if (!rndf)
            tm_printf("No more random file slots \n");
        else
        {
            tc_strcpy(rndf->name, *agv);
            agv++;
            rndf->reclen  = (int)tc_atoi(*agv);
            if ((rndf->fd = po_open(rndf->name, (PO_BINARY|PO_RDWR|PO_CREAT),
                           (PS_IWRITE | PS_IREAD) ) ) < 0)
            {
                 tm_printf_2("Cant open %s\n",rndf->name);
                 /* Note: rndf->fd is still -1 on error */
            }
            else
                return (1);
       }
  }
  tm_printf("Usage: RNDOP D:PATH RECLEN \n");
  return (0);
}


/* CLOSE fd */
int doclose(int agc, char **agv)                                /*__fn__*/
{
    PCFD fd;
    RNDFILE *rndf;

    if (agc == 1)
    {
        fd = tc_atoi(*agv);
        rndf = fndrnd( fd );
        if (!rndf)
            tm_printf("Cant find file\n");
        else
        {
            if (po_close(fd) < 0)
                 tm_printf("Close failed\n");
             else
             {
                rndf->fd = -1;
                return (1);
             }
        }
    }
    tm_printf("Usage: CLOSE fd\n");
    return (0);
}

/* SEEK fd recordno */
int doseek(int agc, char **agv)                                 /*__fn__*/
{
    PCFD fd;
    RNDFILE *rndf;
    int recno;
    long foff;
    long seekret;

    if (agc == 2)
    {
        fd = tc_atoi(*agv);
        rndf = fndrnd(fd);
        if (!rndf)
            tm_printf("Cant find file\n");
        else
        {
            agv++;
            recno = tc_atoi(*agv);
            foff = (long) recno * rndf->reclen;

            if (foff !=(seekret = po_lseek(fd, foff, PSEEK_SET ) ))
            {
                 tm_printf_3("Seek failed got/should'a = %li %li\n", seekret, foff);
            }
            else
                return (1);
        }
    }
    tm_printf("Usage: SEEK fd recordno\n");
    return (0);
}

/* READ fd */
int doread(int agc, char **agv)                                     /*__fn__*/
{
    PCFD fd;
    RNDFILE *rndf;
    int res;

    if (agc == 1)
    {
        fd = (PCFD) tc_atoi(*agv);
        rndf = fndrnd(  fd );
        if (!rndf)
            tm_printf("Cant find file\n");
        else
        {
            if ( (res = po_read(fd,(byte*)rndf->buff,(word)rndf->reclen)) != rndf->reclen)
            {
                tm_printf_3("Cant read %x %x \n",res,rndf->reclen);
            }
            else
            {
                tm_printf_2(":%s:\n", rndf->buff);
                return (1);
            }
        }    
    }
    tm_printf("Usage: READ fd\n");
    return (0);
}

/* WRITE fd "data" */
int dowrite(int agc, char **agv)                                /*__fn__*/
{
    PCFD fd;
    RNDFILE *rndf;
    int res;

    if (agc == 2)
    {
        fd = tc_atoi(*agv);
        rndf = fndrnd(  fd );
        if (!rndf)
            tm_printf("Cant find file\n");
        else
        {
            pc_cppad((byte*)rndf->buff,(byte*) *agv,(int) rndf->reclen);
            rndf->buff[rndf->reclen] = '\0';
            if ( (res = po_write(fd,(byte*)rndf->buff,(word)rndf->reclen)) != rndf->reclen)
            {
                tm_printf_3("Cant write %x %x \n",res,rndf->reclen);
            }
            else
            {
                return (1);
            }
        }    
    }
    tm_printf("Usage: WRITE fd data \n");
    return (0);