efsl_cmds.c

efsl-0.2.8(sd card 文件系统 fat)

//         青藤门客播报站
//Email:   [e-mail]
//Index:   http://blog.ednchina.com/walnutcy/
//


#include    <stdio.h>
#include    <string.h>
#include    <ctype.h>
#include    <stdlib.h>

//#include    "console.h"

#include "efs.h"
#include "ls.h"
#include "mkfs.h"

#include "types.h"
#include "Efsl_cmds.h"



#define	EFSL_F_RDO	0x01	/* Read only */
#define	EFSL_F_HID	0x02	/* Hidden */
#define	EFSL_F_SYS	0x04	/* System */
#define	EFSL_F_VOL	0x08	/* Volume label */
#define EFSL_F_LFN	0x0F	/* LFN entry */
#define EFSL_F_DIR	0x10	/* Directory */
#define EFSL_F_ARC	0x20	/* Archive */

static EmbeddedFileSystem efs;
static EmbeddedFile efsl_file;
static DirList Efsl_DirLst;

long RegisterFunc_Efsl(int argc,char **argv)
{
    eint8 res1;
    euint32 res2;
    
    res2 = efs_init(&efs,&res1);
	if(!res2)
	{
	    _log_Efsl("efs_init successful\n");
	}
	else
	{
	    _log_Efsl("efs_init fail --%d.\n",res2);
	}
	return 0;
}

euint8 mybuffer_Efsl[0x200];

eint8 CurDir_Efsl[400]="/";		//show current dir
eint8 TargetVal_Efsl[400] = "/";  

eint8* CurDirGet(void){return CurDir_Efsl;}

//TargetVal数组第一功能功能：用于组合当前目录与输入数据如 
//CurDir_Efsl = "\mydir"   cat 1.txt 时组合成cat \mydir\1.txt
//第二功能：保留CurDir目录，因为如果cd参数第一个字符为\时就从&CurDir_Efsl[0] 
//开始复制，但若输入目录出错则将原来的CurDir目录还原。

euint32 DirExist_Efsl(const char *DirName);
void RewindRoot_Efsl(void);

void CreateTargetVal_Efsl(const char *arg);

void _dump_file_Efsl(const char *name) 
{
  euint32 x;

  /* open file */
  if (0 == file_fopen(&efsl_file,&efs.myFs,(eint8*)name,(eint8)'r')) 
  {
    /* read until EOF has been reached */
    do 
    {     
      x = file_read(&efsl_file,(euint32)(sizeof(mybuffer_Efsl)),mybuffer_Efsl); 
      if(x) 
      {
        mybuffer_Efsl[x]=0;
        _log_Efsl((eint8*)mybuffer_Efsl);
      }
    } while (x);
    /* close file */
    file_fclose(&efsl_file);
	_log_Efsl("\n");
  }
  else 
  {
    _error_Efsl("Unable to open file %s.\n",name);
  }
}

void _write_file_Efsl(const char *name, const char *txt) 
{
  euint32 x = 0xffffffff;
  /*create file */
  if (0 == file_fopen(&efsl_file,&efs.myFs,(eint8*)name,(eint8)'w'))x=0;
  /*append file-->file has been in cache*/
  else if (0 == file_fopen(&efsl_file,&efs.myFs,(eint8*)name,(eint8)'a'))x=0;

  /*write data to the file*/
  if(x==0)
  {
    x = (euint32)strlen(txt);
    if (x != file_write(&efsl_file,x,(euint8*)txt)) 
    {
      _error_Efsl("Not all bytes written , the written data len is %d bytes.\n",x);
    }
    /* close file */
    file_fclose(&efsl_file);      
	_log_Efsl("\n");
  }
  else 
  {
    _error_Efsl("Unable to create file %s\n",name);
  }
}





//判断目录名是否存在
//1:目录存在  0:目录不存在
euint32 DirExist_Efsl(const char *DirName)
{
    if (ls_openDir(&Efsl_DirLst,&(efs.myFs), (eint8*)DirName) == 0) 
    {
        return 1;
    } 
    else 
    {
		_error_Efsl("unable to open dir: %s\n",DirName);
        return 0;
    }
} 
//--------------------------------------------


void _show_directory_Efsl(const char* path)
{
    euint8 attr;
    _log_Efsl("ls %s\n",path);
    if (ls_openDir( &Efsl_DirLst, &(efs.myFs) ,(eint8*)path) == 0) 
    {
		_log_Efsl(" Name                     \tDir   \tAttr   \tSize\r");
		while ( ls_getNext( &Efsl_DirLst ) == 0 ) 
		{
			Efsl_DirLst.currentEntry.FileName[LIST_MAXLENFILENAME-1] = '\0';
            attr = Efsl_DirLst.currentEntry.Attribute;
            _log_Efsl(" %s          .   %s \t%s%s%s%s ", 
                    Efsl_DirLst.currentEntry.FileName,
                          (attr & EFSL_F_DIR) ? "\t \/   " : "     ",
                          (attr & EFSL_F_ARC) ? "A" : "-",
                          (attr & EFSL_F_RDO) ? "R" : "-",
                          (attr & EFSL_F_HID) ? "H" : "-",
                          (attr & EFSL_F_SYS) ? "S" : "-"
                          );
            if(attr & EFSL_F_DIR)
            {
               _log_Efsl("   \t%lu\n",0);
            }
            else
            {
				eint32 size =  Efsl_DirLst.currentEntry.FileSize;
				
				//显示Gb
				if(size>>30)
					_log_Efsl("  %d   GB",size>>30);
				//显示MB
				size%=(1<<30);
				if(size>>20)
					_log_Efsl("  %d   MB",size>>20);
	
				//显示kbytes
				size%=(1<<20);
				if(size>>10)
					_log_Efsl("  %d   KB",size>>10);


				//显示 bytes
				size%=(1<<10);
				_log_Efsl("  %d   \tbytes",size);
            } 
            _log_Efsl("\n");
		}
    }
}

long ShowFunc_Efsl(int argc,char **argv)
{
	_log_Efsl("TargetVal_Efsl      :%s\n",TargetVal_Efsl);
    return 0;
}

long pwdFunc_Efsl(int argc,char **argv)
{
	if (argc != 0)
	{
		_error_Efsl("PWD is single arg\n");
		return 1;
	}
	_log_Efsl("CurDir_Efsl(pwd)    :%s\n",CurDir_Efsl);

	//debug 
	ShowFunc_Efsl(argc,argv);
	return 0;
}
//功能：设置成根目录
void RewindRoot_Efsl(void)
{
    CurDir_Efsl[0] = '/';
    CurDir_Efsl[1] = '\0';
}

//==========================================debug
size_t strlen(const char*buf)
{
    const char*bufbegin = buf;
	while(*buf!='\0')buf++;
	return (unsigned int)(buf-bufbegin);
}

int strcmp(const char * s1, const char * s2)
{
	if(!s1||!s2)return 0;
	while(*s1!='\0'&&*s2!='0'){
		if(*s1==*s2){s1++;s2++;continue;}
		else if(*s1>*s2)return 1;
		else return -1;
	}

	if(*s1!=0)return 1;
	if(*s2!=0)return -1;
	return 0;
}

char *strncpy(char *s1, const char *s2, size_t n)
{	
	size_t i=0;
 	if(!s1||!s2||!n)return (char*)0;
	 while(n>0)
	 {
	 	s1[i]= *s2;
		i++;s2++;
		n--;
	 }
	 s1[i]='\0';
	 return s1;
}
//==========================================end of debug
//更改当前目录命令
long cdFunc_Efsl(int argc,char **argv)
{
	euint32 DirCurPos = strlen(CurDir_Efsl);   //取得当前目录的字符长度0;
	euint32 TmpVal    = 0;

    if (argc < 1)
	{
		_error_Efsl("please input command as:cd directoryname ");
        _error_Efsl("\n cd \\ change to root\n cd .. \n cd \\MyDir\\Dir1\n");
		_error_Efsl("\n\n");
		return 1;
	}

	/*==================================================================
	*					   cd ..
	==================================================================*/
	if (strcmp(argv[0], "..") == 0)  //回到上一级
	{
		if (1 == DirCurPos)         //设定长度为1的为根目录
		{
			_error_Efsl("   This is root dir:%s\n",CurDir_Efsl);
			return 1;
		} 
		else 
		{
			TmpVal = DirCurPos;   //取得当前目录的长度并从最后开始查找
		   //从最后开始查找将该级目录清除 
           //例：\my\dir1  从1开始找到r最后找到\dir的\清除
            while (TmpVal--) 
		   {
			   if (CurDir_Efsl[TmpVal] == '/')   //是否找到上一级目录
			   {
				   if (TmpVal == 0)         //根目录
				   {
					   RewindRoot_Efsl();
				   } else {
				      CurDir_Efsl[TmpVal] = '\0';   //将最后的\换成结束符
				   }
                   _log_Efsl("   CurDir_Efsl Len = %d\n", strlen(CurDir_Efsl));
				   break;    //退出循环
               } else {
                   CurDir_Efsl[TmpVal] = '\0';  //清除字符
               }
		   }
		}
    }
	/*==================================================================
	*					   cd /
	==================================================================*/
    else if (strcmp(argv[0], "/") == 0)	
    {   
		RewindRoot_Efsl();   //回到根目录
		return 0;
	}
	/*==================================================================
	*					 cd . cd ..  cd dir	 or  cd /dir
	==================================================================*/
	else 
	{
	  	//保存当前目录
         strncpy(&TargetVal_Efsl[0], &CurDir_Efsl[0],(DirCurPos+1));

		//cd dir 加入后面，cd /dir 全部复制
		if(argv[0][0]=='/')strncpy(&CurDir_Efsl[0], argv[0], (strlen(argv[0])+1)); 
		else {
		   //cd dir 前加入"/"
		   if(CurDir_Efsl[DirCurPos-1]!='/'){CurDir_Efsl[DirCurPos]='/';DirCurPos++;}

		   strncpy(&CurDir_Efsl[DirCurPos], argv[0], (strlen(argv[0])+1));
		}  

		//判断目录存在
		if (DirExist_Efsl(CurDir_Efsl) == 0)//不存在
		{
            _log_Efsl("   Dir is not exist!Dir = (%s)\n",argv[0]);
			//恢复原来目录
			strncpy(&CurDir_Efsl[0],&TargetVal_Efsl[0] ,(strlen(TargetVal_Efsl)+1)); 
			//
			return 1;
		}else
		{
		     //_log_Efsl("Open %s Exist!\n", CurDir_Efsl);  //目录存在
			 //return 0;
		}
	}
	//打印当前目录
	_log_Efsl("   CurDir = %s \n", CurDir_Efsl);
	return 1;
}

long lsFunc_Efsl(int argc,char **argv)
{			

	if(argc == 0)
    {
        _show_directory_Efsl(CurDir_Efsl);
    } 
    else 
    {
        _show_directory_Efsl(argv[0]);
    }
	return 0;
}
		

long rmFunc_Efsl(int argc,char **argv)
{
	if(argc != 1)
	{
		_error_Efsl("please input command as:rm filename");
		_error_Efsl("\n\n");
		return 1;
	}
    CreateTargetVal_Efsl(argv[0]);
    if(0 == rmfile(&efs.myFs,(euint8*)TargetVal_Efsl))
	{
		_log_Efsl("remove ");
		_log_Efsl(argv[0]);
		_log_Efsl(" successful\n\n");
	}
	else
	{
		_error_Efsl("remove failure!\n\n");
	}
	return 0;
}

long writeFunc_Efsl(int argc,char **argv)
{
	if(argc != 2)
	{
		_error_Efsl("please input command as:create filename data");
		_error_Efsl("\n\n");
		return 1;
	}
    CreateTargetVal_Efsl(argv[0]);

    _write_file_Efsl(TargetVal_Efsl, argv[1]);

	return 0;
}


//用于将arg参数构造成CurDir + arg = TargetParam
void CreateTargetVal_Efsl(const char *arg)
{
    euint32 CurDirLen = 0;

    CurDirLen = strlen(CurDir_Efsl);
    if ('/' == arg[0])
    {
        strncpy(&TargetVal_Efsl[0], arg, strlen(arg) + 1);
    } 
    else 
    {
        if (1 == CurDirLen)  //判断是否当前目录
        {
            strncpy(&TargetVal_Efsl[CurDirLen], arg, strlen(arg) + 1);
        } 
        else 
        {
            strncpy(TargetVal_Efsl, CurDir_Efsl, CurDirLen + 1);
            TargetVal_Efsl[CurDirLen++] = '/';
            _log_Efsl("\n %s\n", TargetVal_Efsl);
            strncpy(&TargetVal_Efsl[CurDirLen], arg, strlen(arg) + 1);
        }
    }
    _log_Efsl("\nTargetVal = %s\n", TargetVal_Efsl);
}

long catFunc_Efsl(int argc,char **argv)
{
    if(argc != 1)
	{
		_error_Efsl("please input command as:cat filename");
		_error_Efsl("\n\n");
		return 1;
	}
    CreateTargetVal_Efsl(argv[0]);
    _dump_file_Efsl(TargetVal_Efsl);
	return 0;
}



long mkdirFunc_Efsl(int argc,char **argv)
{
	if(argc != 1)