00001
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059 #include <string.h>
00060 #include <math.h>
00061 #include "compiler.h"
00062 #include "board.h"
00063
00064 #include "shell.h"
00065 #include "sensor.h"
00066 #include "actuator.h"
00067 #include "fsaccess.h"
00068 #include "fscmds.h"
00069 #include "supervisor.h"
00070 #include "com1shell.h"
00071 #include "tracedump.h"
00072
00073
00074
00075
00076
00077
00078
00082 const signed portCHAR *const FSCMDS_MSG_APPEND_WELCOME = (signed portCHAR *)CRLF"Simple text editor, enter char to append, ^q to exit and save"CRLF;
00083 const signed portCHAR *const FSCMDS_MSG_HELP = (signed portCHAR *)"\
00084 "CRLF"disk: get the number of drives"CRLF"\
00085 a:, b:, etc.: go to selected drive"CRLF"\
00086 mount drivename (a, b, etc.): go to selected drive"CRLF"\
00087 format drivename (a, b, etc.): format selected drive"CRLF"\
00088 fat: get FAT type used by current drive"CRLF"\
00089 df: get free space information for all connected drives"CRLF"\
00090 cd dirname: go to selected directory"CRLF"\
00091 cd ..: go to upper directory"CRLF"\
00092 mark: bookmark current directory"CRLF"\
00093 goto: go to bookmarked directory"CRLF"\
00094 ls: list files and directories in current directory"CRLF"\
00095 pwd: get current path"CRLF"\
00096 rm filename: remove selected file or empty directory"CRLF"\
00097 rm -R foldername: remove selected directory and its content"CRLF"\
00098 rm *: remove all files or empty directories in current directory"CRLF"\
00099 cp filename: copy filename to bookmarked directory"CRLF"\
00100 mv src dst: rename selected file or directory"CRLF"\
00101 mkdir dirname: make directory"CRLF"\
00102 touch filename: create file"CRLF"\
00103 append filename: append to selected file from terminal input"CRLF"\
00104 cat filename: list file contents"CRLF;
00105
00106
00111 const signed portCHAR *const FSCMDS_ERRMSG_MOUNT_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: mount {a,b,c,d}"CRLF;
00112
00114 const signed portCHAR *const FSCMDS_ERRMSG_MOUNTSHORT_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: {a:,b:,c:,d:}"CRLF;
00115
00117 const signed portCHAR *const FSCMDS_ERRMSG_MOUNT_DRIVENOTFOUND = (signed portCHAR *)ERROR_CRLF"Drive not found."CRLF;
00118
00120 const signed portCHAR *const FSCMDS_ERRMSG_MOUNT_FAILED = (signed portCHAR *)ERROR_CRLF"Unable to mount drive"CRLF;
00121
00123 const signed portCHAR *const FSCMDS_ERRMSG_HW = (signed portCHAR *)ERROR_CRLF"Hardware error"CRLF;
00124
00126 const signed portCHAR *const FSCMDS_ERRMSG_FS = (signed portCHAR *)ERROR_CRLF"File system error"CRLF;
00127
00129 const signed portCHAR *const FSCMDS_ERRMSG_NOFORMAT = (signed portCHAR *)ERROR_CRLF"Current drive is not formatted"CRLF;
00130
00132 const signed portCHAR *const FSCMDS_ERRMSG_MEMDEVMISSING = (signed portCHAR *)ERROR_CRLF"Memory device is missing"CRLF;
00133
00135 const signed portCHAR *const FSCMDS_ERRMSG_NOPARTITION = (signed portCHAR *)ERROR_CRLF"The selected partition doesn't exist"CRLF;
00136
00138 const signed portCHAR *const FSCMDS_ERRMSG_FSNOTSUPPORTED = (signed portCHAR *)ERROR_CRLF"Unsupported file system"CRLF;
00139
00141 const signed portCHAR *const FSCMDS_ERRMSG_UNEXPECTED = (signed portCHAR *)ERROR_CRLF"Unexpected error"CRLF;
00142
00144 const signed portCHAR *const FSCMDS_ERRMSG_NOMOUNT = (signed portCHAR *)ERROR_CRLF"No drive mounted"CRLF;
00145
00147 const signed portCHAR *const FSCMDS_ERRMSG_FILENOTFOUND = (signed portCHAR *)ERROR_CRLF"File not found"CRLF;
00148
00150 const signed portCHAR *const FSCMDS_ERRMSG_NOTFOUND = (signed portCHAR *)ERROR_CRLF"File or directory not found"CRLF;
00151
00153 const signed portCHAR *const FSCMDS_ERRMSG_NOTAFILE = (signed portCHAR *)ERROR_CRLF"Not a file"CRLF;
00154
00156 const signed portCHAR *const FSCMDS_ERRMSG_FILEWR = (signed portCHAR *)ERROR_CRLF"File currently opened in write-mode"CRLF;
00157
00159 const signed portCHAR *const FSCMDS_ERRMSG_READONLYDRIVE = (signed portCHAR *)ERROR_CRLF"Drive is read-only"CRLF;
00160
00162 const signed portCHAR *const FSCMDS_ERRMSG_BADSIZEFAT = (signed portCHAR *)ERROR_CRLF"Unsupported drive size"CRLF;
00163
00165 const signed portCHAR *const FSCMDS_ERRMSG_CD_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: cd dirname"CRLF;
00167 const signed portCHAR *const FSCMDS_ERRMSG_CD_UNKNOWNDIR = (signed portCHAR *)ERROR_CRLF"Unknown directory"CRLF;
00168
00170 const signed portCHAR *const FSCMDS_ERRMSG_LS_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: ls"CRLF;
00171
00173 const signed portCHAR *const FSCMDS_ERRMSG_CAT_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: cat filename"CRLF;
00174
00176 const signed portCHAR *const FSCMDS_ERRMSG_APPEND_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: append filename"CRLF;
00177
00179 const signed portCHAR *const FSCMDS_ERRMSG_HELP_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: help"CRLF;
00180
00182 const signed portCHAR *const FSCMDS_ERRMSG_MAINTENANCE = (signed portCHAR *)ERROR_CRLF"File system access forbidden(Maintenance mode)"CRLF;
00183
00185 const signed portCHAR *const FSCMDS_ERRMSG_FORMAT_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: format {a,b,c,d}"CRLF;
00186
00188 const signed portCHAR *const FSCMDS_ERRMSG_TOUCH_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: touch filename"CRLF;
00189
00191 const signed portCHAR *const FSCMDS_ERRMSG_OUTOFMEM = (signed portCHAR *)ERROR_CRLF"Operation canceled: out of memory"CRLF;
00192
00194 const signed portCHAR *const FSCMDS_ERRMSG_INCORRECTNAME = (signed portCHAR *)ERROR_CRLF"Incorrect name, this must be not contain char \\/:*?\"<>|"CRLF;
00195
00197 const signed portCHAR *const FSCMDS_ERRMSG_MKDIR_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: mkdir dirname"CRLF;
00198
00200 const signed portCHAR *const FSCMDS_ERRMSG_MKDIR_NAMEEXISTS = (signed portCHAR *)ERROR_CRLF"Name already used."CRLF;
00201
00203 const signed portCHAR *const FSCMDS_ERRMSG_ISROOTDIR = (signed portCHAR *)ERROR_CRLF"Current dir is a root dir."CRLF;
00204
00206 const signed portCHAR *const FSCMDS_ERRMSG_RM_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: rm {-R} {filename,dirname,*}"CRLF;
00207
00209 const signed portCHAR *const FSCMDS_ERRMSG_DIRNOTEMPTY = (signed portCHAR *)ERROR_CRLF"Directory not empty."CRLF;
00210
00212 const signed portCHAR *const FSCMDS_ERRMSG_DISK_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: disk"CRLF;
00213
00215 const signed portCHAR *const FSCMDS_ERRMSG_DF_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: df"CRLF;
00216
00218 const signed portCHAR *const FSCMDS_ERRMSG_FAT_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: fat"CRLF;
00219
00221 const signed portCHAR *const FSCMDS_ERRMSG_MV_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: mv src dst"CRLF;
00222
00224 const signed portCHAR *const FSCMDS_ERRMSG_MV_TYPEDIFFER = (signed portCHAR *)ERROR_CRLF"Src & dst must be of the same type."CRLF;
00225
00227 const signed portCHAR *const FSCMDS_ERRMSG_MARK_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: mark"CRLF;
00228
00230 const signed portCHAR *const FSCMDS_ERRMSG_GOTO_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: goto"CRLF;
00231
00233 const signed portCHAR *const FSCMDS_ERRMSG_CP_SYNTAXERROR = (signed portCHAR *)ERROR_CRLF"Usage: cp filename"CRLF;
00234
00235
00237 static portCHAR str_ascii[MAX_FILE_PATH_LENGTH];
00238
00240 static Fs_index ax_mark_index[SYS_NB_MOD];
00241
00242
00243 static eFsCmdsStatus prv_ls( eModId xModId, signed short FsNavId );
00244 static eFsCmdsStatus prv_cat( eModId xModId, signed short FsNavId,
00245 const FS_STRING pcStringFilename );
00246 static eFsCmdsStatus prv_append( eModId xModId, signed short FsNavId,
00247 const FS_STRING pcStringFilename );
00248 static eFsCmdsStatus prvCommonErrorLeave( void );
00249 static Bool prv_NameExists( const FS_STRING pxStringName );
00250 static eFsCmdsStatus prv_df( eModId xModId, signed short FsNavId );
00251 static eFsCmdsStatus prv_cp( eModId xModId, signed short FsNavId,
00252 const FS_STRING pStringFilename );
00253 static void prv_Print_String_To_Requester_Stream( eModId xModId,
00254 const portCHAR * StringToPrint );
00255
00256
00257
00258
00259
00260
00261
00262
00263
00272 eFsCmdsStatus e_fscmds_mount( signed short FsNavId, unsigned short u8DriveId)
00273 {
00274 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
00275
00276
00277 if( u8DriveId >= nav_drive_nb() )
00278 {
00279 eFsStatus = FSCMDS_STATUS_ERR_DRIVE;
00280 }
00281 else
00282 {
00283 fsaccess_take_mutex();
00284 nav_select(FsNavId);
00285 nav_drive_set(u8DriveId);
00286 if (FALSE == nav_partition_mount())
00287 {
00288 eFsStatus = e_fscmds_CheckNavError();
00289 }
00290 fsaccess_give_mutex();
00291 }
00292 return( eFsStatus );
00293 }
00294
00295
00314 eExecStatus e_fscmds_shell_mount( eModId xModId, signed short FsNavId,
00315 int ac, signed portCHAR *av[],
00316 signed portCHAR **ppcStringReply )
00317 {
00318 unsigned int u8DriveId;
00319 eFsCmdsStatus eFsStatus;
00320 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00321
00322
00323
00324
00325 if( 1 != ac )
00326 {
00327 if(ppcStringReply != NULL)
00328 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNT_SYNTAXERROR;
00329 return( SHELL_EXECSTATUS_KO );
00330 }
00331
00332 u8DriveId = av[0][0] - 'a';
00333 if( ( av[0][1] != '\0' ) && ( av[0][1] != ':' ) )
00334 {
00335 if(ppcStringReply != NULL)
00336 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNT_DRIVENOTFOUND;
00337 return( SHELL_EXECSTATUS_KO );
00338 }
00339
00340
00341 eFsStatus = e_fscmds_mount(FsNavId, u8DriveId);
00342 if( FSCMDS_STATUS_OK == eFsStatus )
00343 {
00344 if(ppcStringReply != NULL)
00345 *ppcStringReply = NULL;
00346 eRetStatus = SHELL_EXECSTATUS_OK;
00347 }
00348 else if( ppcStringReply != NULL )
00349 {
00350 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00351 }
00352
00353 return( eRetStatus );
00354 }
00355
00356
00357
00358
00359
00360
00369 eFsCmdsStatus e_fscmds_cd( signed short FsNavId, FS_STRING pxStringDirName )
00370 {
00371 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
00372
00373
00374 fsaccess_take_mutex();
00375 nav_select(FsNavId);
00376
00377
00378 if(nav_setcwd(pxStringDirName, TRUE, FALSE)==FALSE)
00379 {
00380 eFsStatus = e_fscmds_CheckNavError();
00381 }
00382
00383 fsaccess_give_mutex();
00384 return( eFsStatus );
00385 }
00386
00405 eExecStatus e_fscmds_shell_cd( eModId xModId, signed short FsNavId,
00406 int ac, signed portCHAR *av[],
00407 signed portCHAR **ppcStringReply )
00408 {
00409 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
00410 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00411 FS_STRING pxDirName;
00412
00413
00414
00415
00416 if( 1 != ac )
00417 {
00418 if(ppcStringReply != NULL)
00419 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_CD_SYNTAXERROR;
00420 return( SHELL_EXECSTATUS_KO );
00421 }
00422
00423
00424
00425 pxDirName = (FS_STRING)pvPortMalloc( ( strlen( (char *)av[0] ) +2 ) * sizeof( FS_STRING ) );
00426 if( NULL == pxDirName )
00427 {
00428 if(ppcStringReply != NULL)
00429 *ppcStringReply = (signed portCHAR *)SHELL_ERRMSG_MEMALLOC;
00430 return( SHELL_EXECSTATUS_KO );
00431 }
00432 strcpy((char *)pxDirName, (char *)av[0]);
00433 strcat((char *)pxDirName, "\\");
00434
00435 eFsStatus = e_fscmds_cd( FsNavId, pxDirName );
00436
00437 vPortFree( pxDirName );
00438
00439 if( FSCMDS_STATUS_OK == eFsStatus )
00440 {
00441 if(ppcStringReply != NULL)
00442 *ppcStringReply = NULL;
00443 eRetStatus = SHELL_EXECSTATUS_OK;
00444 }
00445 else if( ppcStringReply != NULL )
00446 {
00447 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00448 }
00449
00450 return( eRetStatus );
00451 }
00452
00453
00454
00455
00473 eExecStatus e_fscmds_shell_pwd( eModId xModId, signed short FsNavId,
00474 int ac, signed portCHAR *av[],
00475 signed portCHAR **ppcStringReply )
00476 {
00477 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
00478 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00479 signed portCHAR *pcStringToPrint;
00480
00481
00482
00483
00484 if( 0 != ac )
00485 {
00486 if(ppcStringReply != NULL)
00487 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_LS_SYNTAXERROR;
00488 return( eRetStatus );
00489 }
00490
00491
00492 fsaccess_take_mutex();
00493 nav_select( FsNavId );
00494
00495 pcStringToPrint = (signed portCHAR *)pvPortMalloc( SHELL_MAX_MSGOUT_LEN );
00496 if( NULL == pcStringToPrint )
00497 {
00498 fsaccess_give_mutex();
00499 return( SHELL_EXECSTATUS_KO );
00500 }
00501
00502
00503 if (FALSE == nav_getcwd((FS_STRING)pcStringToPrint, SHELL_MAX_MSGOUT_LEN, FALSE))
00504 {
00505
00506 eFsStatus = e_fscmds_CheckNavError();
00507 }
00508 else
00509 {
00510 prv_Print_String_To_Requester_Stream( xModId, (portCHAR *)pcStringToPrint );
00511 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)CRLF );
00512 }
00513
00514 vPortFree( pcStringToPrint );
00515
00516 fsaccess_give_mutex();
00517
00518 if( FSCMDS_STATUS_OK == eFsStatus )
00519 {
00520 if(ppcStringReply != NULL)
00521 *ppcStringReply = NULL;
00522 eRetStatus = SHELL_EXECSTATUS_OK;
00523 }
00524 else if( ppcStringReply != NULL )
00525 {
00526 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00527 }
00528
00529 return( eRetStatus );
00530 }
00531
00532
00533
00534
00535
00553 eExecStatus e_fscmds_shell_ls( eModId xModId, signed short FsNavId,
00554 int ac, signed portCHAR *av[],
00555 signed portCHAR **ppcStringReply )
00556 {
00557 eFsCmdsStatus eFsStatus;
00558 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00559
00560
00561
00562
00563 if( 0 != ac )
00564 {
00565 if(ppcStringReply != NULL)
00566 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_LS_SYNTAXERROR;
00567 return( eRetStatus );
00568 }
00569
00570
00571 eFsStatus = prv_ls( xModId, FsNavId );
00572 if( FSCMDS_STATUS_OK == eFsStatus )
00573 {
00574 if(ppcStringReply != NULL)
00575 *ppcStringReply = NULL;
00576 eRetStatus = SHELL_EXECSTATUS_OK;
00577 }
00578 else if( ppcStringReply != NULL )
00579 {
00580 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00581 }
00582
00583 return( eRetStatus );
00584 }
00585
00586
00587
00588
00589
00590
00609 eExecStatus e_fscmds_shell_cat( eModId xModId, signed short FsNavId,
00610 int ac, signed portCHAR *av[],
00611 signed portCHAR **ppcStringReply )
00612 {
00613 eFsCmdsStatus eFsStatus;
00614 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00615
00616
00617
00618 if( 1 != ac )
00619 {
00620 if(ppcStringReply != NULL)
00621 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_CAT_SYNTAXERROR;
00622 return( eRetStatus );
00623 }
00624
00625
00626 eFsStatus = prv_cat( xModId, FsNavId, (FS_STRING)av[0] );
00627
00628 if( FSCMDS_STATUS_OK == eFsStatus )
00629 {
00630 if(ppcStringReply != NULL)
00631 *ppcStringReply = NULL;
00632 eRetStatus = SHELL_EXECSTATUS_OK;
00633 }
00634 else if( ppcStringReply != NULL )
00635 {
00636 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00637 }
00638
00639 return( eRetStatus );
00640 }
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665 eExecStatus e_fscmds_shell_append( eModId xModId, signed short FsNavId,
00666 int ac, signed portCHAR *av[],
00667 signed portCHAR **ppcStringReply )
00668 {
00669 eFsCmdsStatus eFsStatus;
00670 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00671
00672
00673
00674
00675 if( 1 != ac )
00676 {
00677 if(ppcStringReply != NULL)
00678 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_APPEND_SYNTAXERROR;
00679 return( eRetStatus );
00680 }
00681
00682
00683 eFsStatus = prv_append( xModId, FsNavId, (FS_STRING)av[0] );
00684
00685 if( FSCMDS_STATUS_OK == eFsStatus )
00686 {
00687 if(ppcStringReply != NULL)
00688 *ppcStringReply = NULL;
00689 eRetStatus = SHELL_EXECSTATUS_OK;
00690 }
00691 else if( ppcStringReply != NULL )
00692 {
00693 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00694 }
00695
00696 return( eRetStatus );
00697 }
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720 eExecStatus e_fscmds_shell_help( eModId xModId, signed short FsNavId,
00721 int ac, signed portCHAR *av[],
00722 signed portCHAR **ppcStringReply )
00723 {
00724
00725 if( ppcStringReply == NULL )
00726 return( SHELL_EXECSTATUS_KO );
00727
00728
00729 *ppcStringReply = (signed portCHAR *)FSCMDS_MSG_HELP;
00730
00731 return( SHELL_EXECSTATUS_OK_NO_FREE );
00732 }
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746 eFsCmdsStatus e_fscmds_touch( signed short FsNavId, const FS_STRING pxStringFilename )
00747 {
00748 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
00749 Fs_index sav_index;
00750 char pcTempoDate[17];
00751
00752 fsaccess_take_mutex();
00753 nav_select(FsNavId);
00754 sav_index = nav_getindex();
00755
00756
00757 if( FALSE == nav_setcwd(pxStringFilename, TRUE, TRUE))
00758 {
00759 file_close();
00760 }
00761
00762 v_cptime_GetDateInFatStringFormat( pcTempoDate );
00763
00764 nav_file_dateset( (FS_STRING)pcTempoDate, FS_DATE_LAST_WRITE );
00765
00766 nav_gotoindex( &sav_index );
00767 fsaccess_give_mutex();
00768 return( eFsStatus );
00769 }
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791 eExecStatus e_fscmds_shell_touch( eModId xModId, signed short FsNavId,
00792 int ac, signed portCHAR *av[],
00793 signed portCHAR **ppcStringReply )
00794 {
00795 eFsCmdsStatus eFsStatus;
00796 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00797
00798
00799
00800
00801 if( 1 != ac )
00802 {
00803 if(ppcStringReply != NULL)
00804 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_TOUCH_SYNTAXERROR;
00805 return( SHELL_EXECSTATUS_KO );
00806 }
00807
00808
00809 eFsStatus = e_fscmds_touch( FsNavId, (FS_STRING)av[0] );
00810
00811 if( FSCMDS_STATUS_OK == eFsStatus )
00812 {
00813 if(ppcStringReply != NULL)
00814 *ppcStringReply = NULL;
00815 eRetStatus = SHELL_EXECSTATUS_OK;
00816 }
00817 else if( ppcStringReply != NULL )
00818 {
00819 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00820 }
00821
00822 return( eRetStatus );
00823 }
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849 eExecStatus e_fscmds_shell_mkdir( eModId xModId, signed short FsNavId,
00850 int ac, signed portCHAR *av[],
00851 signed portCHAR **ppcStringReply )
00852 {
00853 eFsCmdsStatus eFsStatus;
00854 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
00855 char pcTempoDate[17];
00856
00857
00858
00859
00860 if( ( 1 != ac ) || ( NULL != strchr( (char *)av[0], '/' ) ) )
00861 {
00862 if(ppcStringReply != NULL)
00863 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MKDIR_SYNTAXERROR;
00864 return( SHELL_EXECSTATUS_KO );
00865 }
00866
00867
00868 fsaccess_take_mutex();
00869 nav_select(FsNavId);
00870
00871 if( TRUE == prv_NameExists( (FS_STRING)av[0] ) )
00872 {
00873 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MKDIR_NAMEEXISTS;
00874 }
00875 else if( FALSE == nav_dir_make( (FS_STRING)av[0]) )
00876 {
00877 eFsStatus = e_fscmds_CheckNavError();
00878 if( ppcStringReply != NULL )
00879 {
00880 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
00881 }
00882 }
00883 else
00884 {
00885
00886 v_cptime_GetDateInFatStringFormat( pcTempoDate );
00887
00888 nav_file_dateset( (FS_STRING)pcTempoDate, FS_DATE_LAST_WRITE );
00889
00890 if(ppcStringReply != NULL)
00891 *ppcStringReply = NULL;
00892 eRetStatus = SHELL_EXECSTATUS_OK;
00893 }
00894
00895 fsaccess_give_mutex();
00896
00897 return( eRetStatus );
00898 }
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921 eExecStatus e_fscmds_shell_disk( eModId xModId, signed short FsNavId,
00922 int ac, signed portCHAR *av[],
00923 signed portCHAR **ppcStringReply )
00924 {
00925
00926 if( ppcStringReply == NULL )
00927 return( SHELL_EXECSTATUS_KO );
00928
00929
00930
00931 if( 0 != ac )
00932 {
00933 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_DISK_SYNTAXERROR;
00934 return( SHELL_EXECSTATUS_KO );
00935 }
00936
00937
00938 *ppcStringReply = (signed portCHAR *)pvPortMalloc( SHELL_MAX_MSGOUT_LEN );
00939 if( NULL == *ppcStringReply )
00940 {
00941 *ppcStringReply = (signed portCHAR *)SHELL_ERRMSG_MEMALLOC;
00942 return( SHELL_EXECSTATUS_KO );
00943 }
00944 sprintf((char *)*ppcStringReply, "Nb Drive(s): %d"CRLF, nav_drive_nb());
00945
00946 return( SHELL_EXECSTATUS_OK );
00947 }
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970 eExecStatus e_fscmds_shell_df( eModId xModId, signed short FsNavId,
00971 int ac, signed portCHAR *av[],
00972 signed portCHAR **ppcStringReply )
00973 {
00974
00975
00976 if( 0 != ac )
00977 {
00978 if(ppcStringReply != NULL)
00979 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_DF_SYNTAXERROR;
00980 return( SHELL_EXECSTATUS_KO );
00981 }
00982
00983
00984 prv_df( xModId, FsNavId );
00985
00986 if(ppcStringReply != NULL)
00987 *ppcStringReply = NULL;
00988 return( SHELL_EXECSTATUS_OK );
00989 }
00990
00991
00992
00993
00994
00995
01009 eFsCmdsStatus e_fscmds_rm_all( signed short FsNavId, Bool bOnlyEmpty )
01010 {
01011 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
01012
01013
01014 fsaccess_take_mutex();
01015 nav_select(FsNavId);
01016
01017 if( FALSE == nav_filelist_first( FS_DIR ) )
01018 {
01019 nav_filelist_first( FS_FILE );
01020 }
01021
01022 nav_filelist_reset();
01023
01024 while ( nav_filelist_set(0,FS_FIND_NEXT) )
01025 {
01026 if( FALSE == nav_file_del(bOnlyEmpty) )
01027 {
01028 eFsStatus = e_fscmds_CheckNavError();
01029 break;
01030 }
01031 }
01032 fsaccess_give_mutex();
01033
01034 return( eFsStatus );
01035 }
01036
01037
01051 eFsCmdsStatus e_fscmds_rm( signed short FsNavId, const FS_STRING pxStringName,
01052 Bool bOnlyEmpty )
01053 {
01054 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
01055 Fs_index sav_index;
01056
01057
01058 fsaccess_take_mutex();
01059 nav_select( FsNavId );
01060
01061 sav_index = nav_getindex();
01062
01063 if( FALSE == nav_setcwd(pxStringName, TRUE, FALSE))
01064 {
01065 eFsStatus = FSCMDS_STATUS_ERR_NOTFOUND;
01066 }
01067 else if( FALSE == nav_file_del(bOnlyEmpty) )
01068 {
01069 eFsStatus = e_fscmds_CheckNavError();
01070 }
01071 nav_gotoindex( &sav_index );
01072
01073 fsaccess_give_mutex();
01074
01075 return( eFsStatus );
01076 }
01077
01078
01104 eExecStatus e_fscmds_shell_rm( eModId xModId, signed short FsNavId,
01105 int ac, signed portCHAR *av[],
01106 signed portCHAR **ppcStringReply )
01107 {
01108 eFsCmdsStatus eFsStatus;
01109 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
01110
01111
01112
01113 if (( 1 != ac ) && ( 2 != ac ))
01114 {
01115 if(ppcStringReply != NULL)
01116 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_RM_SYNTAXERROR;
01117 return( SHELL_EXECSTATUS_KO );
01118 }
01119
01120
01121 if (!strcmp((char *)av[0], "-R"))
01122 {
01123 if( '*' == av[1][0] )
01124 {
01125
01126 eFsStatus = e_fscmds_rm_all( FsNavId, FALSE );
01127 }
01128 else
01129 {
01130
01131 eFsStatus = e_fscmds_rm( FsNavId, (FS_STRING)av[1], FALSE );
01132 }
01133 }
01134 else if( '*' == av[0][0] )
01135 {
01136
01137 eFsStatus = e_fscmds_rm_all( FsNavId, TRUE );
01138 }
01139 else
01140 {
01141
01142 eFsStatus = e_fscmds_rm( FsNavId, (FS_STRING)av[0], TRUE );
01143 }
01144
01145 if( FSCMDS_STATUS_OK == eFsStatus )
01146 {
01147 if(ppcStringReply != NULL)
01148 *ppcStringReply = NULL;
01149 eRetStatus = SHELL_EXECSTATUS_OK;
01150 }
01151 else if( ppcStringReply != NULL )
01152 {
01153 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01154 }
01155
01156 return( eRetStatus );
01157 }
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180 eExecStatus e_fscmds_shell_fat( eModId xModId, signed short FsNavId,
01181 int ac, signed portCHAR *av[],
01182 signed portCHAR **ppcStringReply )
01183 {
01184 int i=0;
01185
01186
01187
01188
01189 if( 0 != ac )
01190 {
01191 if(ppcStringReply != NULL)
01192 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FAT_SYNTAXERROR;
01193 return( SHELL_EXECSTATUS_KO );
01194 }
01195
01196 fsaccess_take_mutex();
01197 nav_select( FsNavId );
01198
01199
01200 #if FS_FAT_12 == ENABLED
01201 if( Is_fat12 )
01202 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)"Drive uses FAT12"CRLF );
01203 else i++;
01204 #endif
01205 #if FS_FAT_16 == ENABLED
01206 if( Is_fat16 )
01207 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)"Drive uses FAT16"CRLF );
01208 else i++;
01209 #endif
01210 #if FS_FAT_32 == ENABLED
01211 if( Is_fat32 )
01212 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)"Drive uses FAT32"CRLF );
01213 else i++;
01214 #endif
01215
01216 if(3 == i)
01217 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)FSCMDS_ERRMSG_NOMOUNT );
01218
01219 fsaccess_give_mutex();
01220
01221 if(ppcStringReply != NULL)
01222 *ppcStringReply = NULL;
01223 return( SHELL_EXECSTATUS_OK );
01224 }
01225
01226
01227
01228
01229
01245 eExecStatus e_fscmds_goto_drive( unsigned int u8DriveId, signed short FsNavId,
01246 int ac, signed portCHAR **ppcStringReply )
01247 {
01248 eFsCmdsStatus eFsStatus;
01249 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
01250
01251
01252
01253
01254 if( 0 != ac )
01255 {
01256 if(ppcStringReply != NULL)
01257 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNTSHORT_SYNTAXERROR;
01258 return( SHELL_EXECSTATUS_KO );
01259 }
01260
01261
01262 eFsStatus = e_fscmds_mount(FsNavId, u8DriveId);
01263 if( FSCMDS_STATUS_OK == eFsStatus )
01264 {
01265 if(ppcStringReply != NULL)
01266 *ppcStringReply = NULL;
01267 eRetStatus = SHELL_EXECSTATUS_OK;
01268 }
01269 else if( ppcStringReply != NULL )
01270 {
01271 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01272 }
01273
01274 return( eRetStatus );
01275 }
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293 eExecStatus e_fscmds_shell_goto_a_drive( eModId xModId, signed short FsNavId,
01294 int ac, signed portCHAR *av[],
01295 signed portCHAR **ppcStringReply )
01296 {
01297 return( e_fscmds_goto_drive( 'a'-'a', FsNavId, ac, ppcStringReply ) );
01298 }
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316 eExecStatus e_fscmds_shell_goto_b_drive( eModId xModId, signed short FsNavId,
01317 int ac, signed portCHAR *av[],
01318 signed portCHAR **ppcStringReply )
01319 {
01320 return( e_fscmds_goto_drive( 'b'-'a', FsNavId, ac, ppcStringReply ) );
01321 }
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339 eExecStatus e_fscmds_shell_goto_c_drive( eModId xModId, signed short FsNavId,
01340 int ac, signed portCHAR *av[],
01341 signed portCHAR **ppcStringReply )
01342 {
01343 return( e_fscmds_goto_drive( 'c'-'a', FsNavId, ac, ppcStringReply ) );
01344 }
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362 eExecStatus e_fscmds_shell_goto_d_drive( eModId xModId, signed short FsNavId,
01363 int ac, signed portCHAR *av[],
01364 signed portCHAR **ppcStringReply )
01365 {
01366 return( e_fscmds_goto_drive( 'd'-'a', FsNavId, ac, ppcStringReply ) );
01367 }
01368
01369
01370
01371
01372
01373
01381 static int prv_i_GetIdxFromModid( eModId xModId )
01382 {
01383 int exp;
01384
01385
01386 frexp(xModId,&exp);
01387 return(exp-1);
01388 }
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406 eExecStatus e_fscmds_shell_mark( eModId xModId, signed short FsNavId,
01407 int ac, signed portCHAR *av[],
01408 signed portCHAR **ppcStringReply )
01409 {
01410
01411
01412 if( 0 != ac )
01413 {
01414 if(ppcStringReply != NULL)
01415 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MARK_SYNTAXERROR;
01416 return( SHELL_EXECSTATUS_KO );
01417 }
01418
01419
01420 fsaccess_take_mutex();
01421 nav_select( FsNavId );
01422
01423 ax_mark_index[prv_i_GetIdxFromModid(xModId)] = nav_getindex();
01424
01425 fsaccess_give_mutex();
01426 if(ppcStringReply != NULL)
01427 *ppcStringReply = NULL;
01428 return( SHELL_EXECSTATUS_OK );
01429 }
01430
01431
01432
01433
01434
01452 eExecStatus e_fscmds_shell_goto( eModId xModId, signed short FsNavId,
01453 int ac, signed portCHAR *av[],
01454 signed portCHAR **ppcStringReply )
01455 {
01456 eFsCmdsStatus eFsStatus;
01457
01458
01459 if( 0 != ac )
01460 {
01461 if(ppcStringReply != NULL)
01462 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_GOTO_SYNTAXERROR;
01463 return( SHELL_EXECSTATUS_KO );
01464 }
01465
01466
01467 fsaccess_take_mutex();
01468 nav_select( FsNavId );
01469 if( FALSE == nav_gotoindex( &(ax_mark_index[prv_i_GetIdxFromModid( xModId )]) ) )
01470 {
01471 eFsStatus = prvCommonErrorLeave();
01472 if( ppcStringReply != NULL )
01473 {
01474 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01475 }
01476 return( SHELL_EXECSTATUS_KO );
01477 }
01478 else
01479 fsaccess_give_mutex();
01480
01481 if(ppcStringReply != NULL)
01482 *ppcStringReply = NULL;
01483 return( SHELL_EXECSTATUS_OK );
01484 }
01485
01486
01487
01488
01489
01498 eFsCmdsStatus e_fscmds_format( signed short FsNavId, unsigned short u8DriveId )
01499 {
01500 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
01501 unsigned short u8CurrentDriveId;
01502
01503
01504 if( u8DriveId >= nav_drive_nb() )
01505 {
01506 eFsStatus = FSCMDS_STATUS_ERR_DRIVE;
01507 }
01508 else
01509 {
01510 fsaccess_take_mutex();
01511 nav_select(FsNavId);
01512 u8CurrentDriveId = nav_drive_get();
01513 nav_drive_set(u8DriveId);
01514 if( FALSE == nav_drive_format( FS_FORMAT_DEFAULT ) )
01515 {
01516 eFsStatus = e_fscmds_CheckNavError();
01517 nav_drive_set( u8CurrentDriveId );
01518 }
01519 else if( u8DriveId == u8CurrentDriveId )
01520 {
01521
01522
01523 nav_filelist_reset();
01524 nav_drive_set(u8DriveId);
01525 if (FALSE == nav_partition_mount())
01526 {
01527 eFsStatus = e_fscmds_CheckNavError();
01528 }
01529 }
01530 else
01531
01532 nav_drive_set( u8CurrentDriveId );
01533 fsaccess_give_mutex();
01534 }
01535 return( eFsStatus );
01536 }
01537
01538
01557 eExecStatus e_fscmds_shell_format( eModId xModId, signed short FsNavId,
01558 int ac, signed portCHAR *av[],
01559 signed portCHAR **ppcStringReply )
01560 {
01561 unsigned int u8DriveId;
01562 eFsCmdsStatus eFsStatus;
01563 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
01564
01565
01566
01567
01568 if( 1 != ac )
01569 {
01570 if(ppcStringReply != NULL)
01571 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FORMAT_SYNTAXERROR;
01572 return( SHELL_EXECSTATUS_KO );
01573 }
01574
01575 u8DriveId = av[0][0] - 'a';
01576 if( ( av[0][1] != '\0' ) && ( av[0][1] != ':' ) )
01577 {
01578 if(ppcStringReply != NULL)
01579 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNT_DRIVENOTFOUND;
01580 return( SHELL_EXECSTATUS_KO );
01581 }
01582
01583
01584 eFsStatus = e_fscmds_format(FsNavId, u8DriveId);
01585 if( FSCMDS_STATUS_OK == eFsStatus )
01586 {
01587 if(ppcStringReply != NULL)
01588 *ppcStringReply = NULL;
01589 eRetStatus = SHELL_EXECSTATUS_OK;
01590 }
01591 else if( ppcStringReply != NULL )
01592 {
01593 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01594 }
01595
01596 return( eRetStatus );
01597 }
01598
01599
01600
01601
01602
01623 eExecStatus e_fscmds_shell_cp( eModId xModId, signed short FsNavId,
01624 int ac, signed portCHAR *av[],
01625 signed portCHAR **ppcStringReply )
01626 {
01627 eFsCmdsStatus eFsStatus;
01628 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
01629
01630
01631 if( 1 != ac )
01632 {
01633
01634 if(ppcStringReply != NULL)
01635 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_CP_SYNTAXERROR;
01636 return( eRetStatus );
01637 }
01638
01639
01640 eFsStatus = prv_cp( xModId, FsNavId, (FS_STRING)av[0] );
01641
01642 if( FSCMDS_STATUS_OK == eFsStatus )
01643 {
01644 if(ppcStringReply != NULL)
01645 *ppcStringReply = NULL;
01646 eRetStatus = SHELL_EXECSTATUS_OK;
01647 }
01648 else if( ppcStringReply != NULL )
01649 {
01650 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01651 }
01652
01653 return( eRetStatus );
01654 }
01655
01656
01657
01658
01659
01681 eExecStatus e_fscmds_shell_mv( eModId xModId, signed short FsNavId,
01682 int ac, signed portCHAR *av[],
01683 signed portCHAR **ppcStringReply )
01684 {
01685 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
01686 eExecStatus eRetStatus = SHELL_EXECSTATUS_KO;
01687 Fs_index sav_index;
01688 Bool bSrcType, bDstType;
01689
01690
01691
01692
01693 if( 2 != ac )
01694 {
01695 if(ppcStringReply != NULL)
01696 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MV_SYNTAXERROR;
01697 return( SHELL_EXECSTATUS_KO );
01698 }
01699
01700
01701 fsaccess_take_mutex();
01702 nav_select(FsNavId);
01703
01704 sav_index = nav_getindex();
01705
01706
01707 if( FALSE == nav_setcwd((FS_STRING)av[0], TRUE, FALSE))
01708 {
01709 eFsStatus = e_fscmds_CheckNavError();
01710 if( ppcStringReply != NULL )
01711 {
01712 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01713 }
01714 }
01715 else
01716 {
01717
01718
01719 bSrcType = nav_file_isdir();
01720 if( TRUE == nav_setcwd((FS_STRING)av[1], TRUE, FALSE))
01721 {
01722 bDstType = nav_file_isdir();
01723 if( bSrcType != bDstType )
01724 {
01725 eFsStatus = FSCMDS_STATUS_KO;
01726 if( ppcStringReply != NULL )
01727 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MV_TYPEDIFFER;
01728 }
01729 else
01730 {
01731 fsaccess_give_mutex();
01732 eFsStatus = e_fscmds_rm( FsNavId, (FS_STRING)av[1], TRUE );
01733 fsaccess_take_mutex();
01734 if( FSCMDS_STATUS_OK != eFsStatus )
01735 {
01736 if( ppcStringReply != NULL )
01737 {
01738 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01739 }
01740 }
01741 }
01742 }
01743
01744 if( FSCMDS_STATUS_OK == eFsStatus )
01745 {
01746
01747 if( FALSE == nav_file_rename( (FS_STRING)av[1] ) )
01748 {
01749 eFsStatus = e_fscmds_CheckNavError();
01750 if( ppcStringReply != NULL )
01751 {
01752 v_fscmds_GetStrMsgFromErr(eFsStatus, ppcStringReply);
01753 }
01754 }
01755 else
01756 {
01757 if(ppcStringReply != NULL)
01758 *ppcStringReply = NULL;
01759 eRetStatus = SHELL_EXECSTATUS_OK;
01760 }
01761 }
01762
01763 }
01764
01765 nav_gotoindex( &sav_index );
01766
01767 fsaccess_give_mutex();
01768
01769 return( eRetStatus );
01770 }
01771
01772
01779 eFsCmdsStatus e_fscmds_CheckNavError( void )
01780 {
01781 switch(fs_g_status)
01782 {
01783 case FS_ERR_HW:
01784 return( FSCMDS_STATUS_ERR_HW );
01785 case FS_ERR_FS:
01786 return( FSCMDS_STATUS_ERR_FS );
01787 case FS_ERR_NO_MOUNT:
01788 return( FSCMDS_STATUS_ERR_NOMOUNT );
01789 case FS_ERR_NO_FORMAT:
01790 return( FSCMDS_STATUS_ERR_NOFORMAT );
01791 case FS_ERR_HW_NO_PRESENT:
01792 return( FSCMDS_STATUS_ERR_MEMDEVMISSING );
01793 case FS_ERR_NO_PART:
01794 return( FSCMDS_STATUS_ERR_NOPARTITION );
01795 case FS_ERR_NO_SUPPORT_PART:
01796 return( FSCMDS_STATUS_ERR_FSNOTSUPPORTED );
01797 case FS_ERR_NO_FIND:
01798 return( FSCMDS_STATUS_ERR_FILENOTFOUND );
01799 case FS_ERR_NO_FILE:
01800 return( FSCMDS_STATUS_ERR_NOTAFILE );
01801 case FS_ERR_FILE_OPEN_WR:
01802 return( FSCMDS_STATUS_ERR_FILEWR );
01803 case FS_LUN_WP:
01804 return( FSCMDS_STATUS_ERR_READONLY );
01805 case FS_ERR_BAD_SIZE_FAT:
01806 return( FSCMDS_STATUS_ERR_BADSIZEFAT );
01807 case FS_ERR_OUT_LIST:
01808 case FS_ERR_NO_FREE_SPACE:
01809 return( FSCMDS_STATUS_ERR_OUTOFMEM );
01810 case FS_ERR_INCORRECT_NAME:
01811 return( FSCMDS_STATUS_ERR_INCORRECTNAME );
01812 case FS_ERR_IS_ROOT:
01813 return( FSCMDS_STATUS_ERR_ISROOTDIR );
01814 case FS_ERR_DIR_NOT_EMPTY:
01815 return( FSCMDS_STATUS_ERR_DIRNOTEMPTY );
01816
01817 default:
01818 NAKED_TRACE_COM2( "Unexpected fs_g_status:%d", fs_g_status );
01819 return( FSCMDS_STATUS_ERR_UNKNOWN );
01820 }
01821 }
01822
01823
01830 void v_fscmds_GetStrMsgFromErr( eFsCmdsStatus ErrStatus, signed portCHAR **ppcStringReply )
01831 {
01832 switch( ErrStatus )
01833 {
01834 case FSCMDS_STATUS_ERR_DRIVE:
01835 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNT_DRIVENOTFOUND;
01836 break;
01837 case FSCMDS_STATUS_ERR_MOUNT:
01838 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MOUNT_FAILED;
01839 break;
01840 case FSCMDS_STATUS_ERR_UNKNOWNDIR:
01841 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_CD_UNKNOWNDIR;
01842 break;
01843 case FSCMDS_STATUS_ERR_HW:
01844 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_HW;
01845 break;
01846 case FSCMDS_STATUS_ERR_FS:
01847 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FS;
01848 break;
01849 case FSCMDS_STATUS_ERR_NOFORMAT:
01850 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_NOFORMAT;
01851 break;
01852 case FSCMDS_STATUS_ERR_NOMOUNT:
01853 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_NOMOUNT;
01854 break;
01855 case FSCMDS_STATUS_ERR_MEMDEVMISSING:
01856 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_MEMDEVMISSING;
01857 break;
01858 case FSCMDS_STATUS_ERR_NOPARTITION:
01859 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_NOPARTITION;
01860 break;
01861 case FSCMDS_STATUS_ERR_FSNOTSUPPORTED:
01862 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FSNOTSUPPORTED;
01863 break;
01864 case FSCMDS_STATUS_ERR_FILENOTFOUND:
01865 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FILENOTFOUND;
01866 break;
01867 case FSCMDS_STATUS_ERR_NOTFOUND:
01868 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_NOTFOUND;
01869 break;
01870 case FSCMDS_STATUS_ERR_NOTAFILE:
01871 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_NOTAFILE;
01872 break;
01873 case FSCMDS_STATUS_ERR_FILEWR:
01874 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_FILEWR;
01875 break;
01876 case FSCMDS_STATUS_ERR_READONLY:
01877 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_READONLYDRIVE;
01878 break;
01879 case FSCMDS_STATUS_ERR_BADSIZEFAT:
01880 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_BADSIZEFAT;
01881 break;
01882 case FSCMDS_STATUS_ERR_OUTOFMEM:
01883 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_OUTOFMEM;
01884 break;
01885 case FSCMDS_STATUS_ERR_INCORRECTNAME:
01886 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_INCORRECTNAME;
01887 break;
01888 case FSCMDS_STATUS_ERR_ISROOTDIR:
01889 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_ISROOTDIR;
01890 break;
01891 case FSCMDS_STATUS_ERR_DIRNOTEMPTY:
01892 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_DIRNOTEMPTY;
01893 break;
01894 case FSCMDS_STATUS_ERR_MEMALLOC:
01895 *ppcStringReply = (signed portCHAR *)SHELL_ERRMSG_MEMALLOC;
01896 break;
01897
01898 case FSCMDS_STATUS_ERR_UNKNOWN:
01899 *ppcStringReply = (signed portCHAR *)FSCMDS_ERRMSG_UNEXPECTED;
01900 break;
01901
01902 default:
01903 break;
01904 }
01905 }
01906
01907
01908
01909
01917 static void prv_Print_String_To_Requester_Stream( eModId xModId, const portCHAR * pStringToPrint )
01918 {
01919 switch( xModId )
01920 {
01921 case SYS_MODID_COM1SHELL:
01922 vcom1shell_PrintMsg((signed portCHAR *) pStringToPrint );
01923 break;
01924 case SYS_MODID_USB:
01925 TRACE_COM2((char *)"Unimplemented stream redirection (from fscmds to USB)");
01926 break;
01927 default:
01928 TRACE_COM2((char *)"Unexpected stream redirection");
01929 break;
01930 }
01931 }
01932
01940 static void prv_PutChar_To_Requester_Stream( eModId xModId, signed portCHAR c )
01941 {
01942 switch( xModId )
01943 {
01944 case SYS_MODID_COM1SHELL:
01945 vcom1shell_PutChar( c );
01946 break;
01947 case SYS_MODID_USB:
01948 TRACE_COM2((char *)"Unimplemented stream redirection (from fscmds to USB)");
01949 break;
01950 default:
01951 TRACE_COM2((char *)"Unexpected stream redirection");
01952 break;
01953 }
01954 }
01955
01964 static signed portCHAR prv_GetChar_From_Requester_Stream( eModId xModId )
01965 {
01966 signed portCHAR cByte;
01967
01968
01969 switch( xModId )
01970 {
01971 case SYS_MODID_COM1SHELL:
01972 while( pdFALSE == com1shell_GetChar( &cByte ) );
01973 break;
01974 case SYS_MODID_USB:
01975 TRACE_COM2((char *)"Unimplemented stream redirection (from USB to fscmds)");
01976 break;
01977 default:
01978 TRACE_COM2((char *)"Unexpected stream redirection");
01979 break;
01980 }
01981 return( cByte );
01982 }
01983
01993 static eFsCmdsStatus prv_ls( eModId xModId, signed short FsNavId )
01994 {
01995 eFsCmdsStatus eFsStatus = FSCMDS_STATUS_OK;
01996 signed portCHAR *pcStringToPrint;
01997
01998
01999
02000 fsaccess_take_mutex();
02001 nav_select( FsNavId );
02002
02003 if( FALSE == nav_dir_name( (FS_STRING) str_ascii, MAX_FILE_PATH_LENGTH ) )
02004 {
02005 return( prvCommonErrorLeave() );
02006 }
02007
02008 pcStringToPrint = (signed portCHAR *)pvPortMalloc( SHELL_MAX_MSGOUT_LEN );
02009 if( NULL == pcStringToPrint )
02010 {
02011 fsaccess_give_mutex();
02012 return( FSCMDS_STATUS_ERR_MEMALLOC );
02013 }
02014
02015
02016 sprintf( (char *)pcStringToPrint, CRLF"Volume is %c: (%s)"CRLF"Dir name is ",
02017 'A'+nav_drive_get(), mem_name( nav_drive_get() ) );
02018 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02019 prv_Print_String_To_Requester_Stream( xModId, str_ascii );
02020 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)CRLF );
02021
02022
02023 if( FALSE == nav_filelist_first( FS_DIR ) )
02024 {
02025 nav_filelist_first( FS_FILE );
02026 }
02027 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)"\tSize (Bytes)\tName"CRLF );
02028 nav_filelist_reset();
02029 while ( nav_filelist_set(0,FS_FIND_NEXT) )
02030 {
02031 sprintf( (char *)pcStringToPrint, "%3s\t%u\t\t",
02032 (nav_file_isdir()) ? "Dir" : "",
02033 (unsigned int)nav_file_lgt() );
02034 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02035 nav_file_name( (FS_STRING)str_ascii, MAX_FILE_PATH_LENGTH, FS_NAME_GET, FALSE );
02036 prv_Print_String_To_Requester_Stream( xModId, str_ascii );
02037 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)CRLF );
02038 }
02039
02040
02041 sprintf( (char *)pcStringToPrint, "%d Files"CRLF"%d Dir"CRLF,
02042 nav_filelist_nb( FS_FILE ),
02043 nav_filelist_nb( FS_DIR ) );
02044 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02045
02046 vPortFree( pcStringToPrint );
02047
02048
02049 fsaccess_give_mutex();
02050 return( eFsStatus );
02051 }
02052
02053
02064 static eFsCmdsStatus prv_cat( eModId xModId, signed short FsNavId, const FS_STRING pStringFilename )
02065 {
02066 signed portCHAR *pcOutString;
02067 size_t filesize;
02068 size_t RequestedSize;
02069 size_t ReadSize;
02070 Fs_index sav_index;
02071
02072
02073 fsaccess_take_mutex();
02074 nav_select(FsNavId);
02075
02076 sav_index = nav_getindex();
02077
02078
02079 if ( FALSE == nav_setcwd(pStringFilename, TRUE, FALSE) )
02080 {
02081 fsaccess_give_mutex();
02082 return( FSCMDS_STATUS_ERR_FILENOTFOUND );
02083 }
02084
02085
02086 if( FALSE == file_open( FOPEN_MODE_R ) )
02087 {
02088 nav_gotoindex( &sav_index );
02089 return( prvCommonErrorLeave() );
02090 }
02091
02092
02093
02094 fsaccess_give_mutex();
02095
02096 filesize = fsaccess_file_get_size( FsNavId );
02097
02098 if(filesize < FS_SIZE_OF_SECTOR)
02099 {
02100 pcOutString = (signed portCHAR *)pvPortMalloc( filesize +1 );
02101 if( NULL == pcOutString )
02102 {
02103 return( FSCMDS_STATUS_ERR_MEMALLOC );
02104 }
02105 RequestedSize = filesize;
02106 }
02107 else
02108 {
02109 pcOutString = (signed portCHAR *)pvPortMalloc( FS_SIZE_OF_SECTOR +1 );
02110 if( NULL == pcOutString )
02111 {
02112 return( FSCMDS_STATUS_ERR_MEMALLOC );
02113 }
02114 RequestedSize = FS_SIZE_OF_SECTOR;
02115 }
02116
02117 while( filesize )
02118 {
02119
02120 ReadSize = read( FsNavId, pcOutString, RequestedSize );
02121 if( ReadSize != RequestedSize )
02122 {
02123 TRACE_COM2("");
02124 vPortFree( pcOutString );
02125
02126 fsaccess_take_mutex();
02127 nav_select( FsNavId );
02128 file_close();
02129 nav_gotoindex( &sav_index );
02130 return( prvCommonErrorLeave() );
02131 }
02132 else
02133 filesize -= ReadSize;
02134
02135 RequestedSize = (filesize < FS_SIZE_OF_SECTOR) ? filesize : FS_SIZE_OF_SECTOR;
02136
02137 *(pcOutString +ReadSize) = '\0';
02138 v_shell_Print_String_To_Requester_Stream( xModId, pcOutString );
02139 }
02140 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)CRLF );
02141
02142 vPortFree( pcOutString );
02143
02144
02145
02146 fsaccess_take_mutex();
02147 nav_select( FsNavId );
02148 file_close();
02149
02150 nav_gotoindex( &sav_index );
02151
02152
02153 fsaccess_give_mutex();
02154
02155 return( FSCMDS_STATUS_OK );
02156 }
02157
02168 static eFsCmdsStatus prv_append( eModId xModId, signed short FsNavId, const FS_STRING pxStringFilename )
02169 {
02170 signed portCHAR cTempoChar;
02171 signed portCHAR cPrevChar=0;
02172 Fs_index sav_index;
02173 char pcTempoDate[17];
02174
02175
02176
02177 fsaccess_take_mutex();
02178 nav_select(FsNavId);
02179
02180 sav_index = nav_getindex();
02181
02182
02183 if(nav_setcwd((FS_STRING)pxStringFilename, TRUE, FALSE)==FALSE)
02184 {
02185 fsaccess_give_mutex();
02186 return( FSCMDS_STATUS_ERR_FILENOTFOUND );
02187 }
02188
02189
02190 if( FALSE == file_open( FOPEN_MODE_APPEND ) )
02191 {
02192 nav_gotoindex( &sav_index );
02193 return( prvCommonErrorLeave() );
02194 }
02195
02196
02197
02198 v_shell_Print_String_To_Requester_Stream( xModId, FSCMDS_MSG_APPEND_WELCOME );
02199
02200 while( 1 )
02201 {
02202 cTempoChar = prv_GetChar_From_Requester_Stream( xModId );
02203 if( cTempoChar == QUIT_APPEND )
02204 {
02205 v_shell_Print_String_To_Requester_Stream( xModId, (signed portCHAR *)CRLF );
02206 break;
02207 }
02208 if( ( cTempoChar == LF ) && ( cPrevChar != CR ) )
02209 {
02210 prv_PutChar_To_Requester_Stream( xModId, CR );
02211 file_putc( CR );
02212 }
02213 prv_PutChar_To_Requester_Stream( xModId, cTempoChar );
02214
02215 if( FALSE == file_putc( cTempoChar ) )
02216 {
02217 file_close();
02218 nav_gotoindex( &sav_index );
02219 return( prvCommonErrorLeave() );
02220 }
02221 if( cTempoChar == CR )
02222 {
02223 prv_PutChar_To_Requester_Stream( xModId, LF );
02224 file_putc( LF );
02225 }
02226 cPrevChar = cTempoChar;
02227 }
02228
02229
02230 v_cptime_GetDateInFatStringFormat( pcTempoDate );
02231
02232 nav_file_dateset( (FS_STRING)pcTempoDate, FS_DATE_LAST_WRITE );
02233
02234
02235 file_close();
02236
02237 nav_gotoindex( &sav_index );
02238
02239
02240 fsaccess_give_mutex();
02241
02242 return( FSCMDS_STATUS_OK );
02243 }
02244
02245
02256 static eFsCmdsStatus prv_df( eModId xModId, signed short FsNavId )
02257 {
02258 signed portCHAR *pcStringToPrint;
02259 signed portCHAR *pcStringErrMsg;
02260 int i,NbDrive;
02261 Fs_index sav_index;
02262 eFsCmdsStatus eFsStatus;
02263
02264
02265 fsaccess_take_mutex();
02266 nav_select( FsNavId );
02267
02268 pcStringToPrint = (signed portCHAR *)pvPortMalloc( SHELL_MAX_MSGOUT_LEN );
02269 if( NULL == pcStringToPrint )
02270 {
02271 fsaccess_give_mutex();
02272 return( FSCMDS_STATUS_ERR_MEMALLOC );
02273 }
02274
02275 sav_index = nav_getindex();
02276 NbDrive = nav_drive_nb();
02277
02278 for( i = 0; i < NbDrive; i++ )
02279 {
02280 if( FALSE == nav_drive_set( i ) )
02281 {
02282 eFsStatus = e_fscmds_CheckNavError();
02283 v_fscmds_GetStrMsgFromErr( eFsStatus, &pcStringErrMsg );
02284 sprintf( (char *)pcStringToPrint, "%s (%c:) %s"CRLF,
02285 mem_name(i),
02286 (char)('a' + i),
02287 pcStringErrMsg );
02288 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02289 }
02290 else if( FALSE == nav_partition_mount() )
02291 {
02292 eFsStatus = e_fscmds_CheckNavError();
02293 v_fscmds_GetStrMsgFromErr( eFsStatus, &pcStringErrMsg );
02294 sprintf( (char *)pcStringToPrint, "%s (%c:) %s"CRLF,
02295 mem_name(i),
02296 (char)('a' + i),
02297 pcStringErrMsg );
02298 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02299 }
02300 else
02301 {
02302 sprintf( (char *)pcStringToPrint, "%s (%c:) Free Space: %llu Bytes / %llu Bytes"CRLF,
02303 mem_name(i),
02304 (char)('a' + i),
02305 (unsigned long long int)(nav_partition_freespace() << FS_SHIFT_B_TO_SECTOR),
02306 (unsigned long long int)(nav_partition_space() << FS_SHIFT_B_TO_SECTOR) );
02307 v_shell_Print_String_To_Requester_Stream( xModId, pcStringToPrint );
02308 }
02309 }
02310 nav_gotoindex( &sav_index );
02311
02312 vPortFree( pcStringToPrint );
02313
02314 fsaccess_give_mutex();
02315 return( FSCMDS_STATUS_OK );
02316 }
02317
02328 static eFsCmdsStatus prv_cp( eModId xModId, signed short FsNavId, const FS_STRING pStringFilename )
02329 {
02330 U16 file_size;
02331 Fs_index sav_index;
02332
02333
02334
02335 fsaccess_take_mutex();
02336 nav_select(FsNavId);
02337
02338
02339 if(nav_setcwd(pStringFilename, TRUE, FALSE)==FALSE)
02340 {
02341 fsaccess_give_mutex();
02342 return( FSCMDS_STATUS_ERR_FILENOTFOUND );
02343 }
02344 else
02345 {
02346
02347 if( FALSE == nav_file_name( pStringFilename, MAX_FILE_PATH_LENGTH, FS_NAME_GET, TRUE) )
02348 {
02349 return( prvCommonErrorLeave() );
02350 }
02351
02352 file_size = nav_file_lgtsector();
02353
02354 nav_file_copy();
02355
02356 sav_index = nav_getindex();
02357
02358 nav_gotoindex( &(ax_mark_index[prv_i_GetIdxFromModid( xModId )]) );
02359
02360 if (nav_partition_space() > file_size)
02361 {
02362
02363 nav_file_paste_start( pStringFilename );
02364
02365 nav_gotoindex( &sav_index );
02366
02367 while(nav_file_paste_state( FALSE ) == COPY_BUSY);
02368
02369 }
02370 nav_gotoindex(&sav_index);
02371 }
02372 fsaccess_give_mutex();
02373 return( FSCMDS_STATUS_OK );
02374 }
02375
02376
02382 static eFsCmdsStatus prvCommonErrorLeave( void )
02383 {
02384 eFsCmdsStatus eFsStatus;
02385
02386 eFsStatus = e_fscmds_CheckNavError();
02387 fsaccess_give_mutex();
02388 return( eFsStatus );
02389 }
02390
02401 static Bool prv_NameExists( const FS_STRING pxStringName )
02402 {
02403 int i;
02404
02405
02406 if( FALSE == nav_filelist_first( FS_DIR ) )
02407 {
02408 nav_filelist_first( FS_FILE );
02409 }
02410 i = nav_filelist_nb( FS_DIR ) + nav_filelist_nb( FS_FILE );
02411 while ( i )
02412 {
02413 nav_file_name( (FS_STRING)str_ascii, MAX_FILE_PATH_LENGTH, FS_NAME_GET, TRUE );
02414 if( 0 == strcmp( (char *)str_ascii, (char *)pxStringName ) )
02415 return( TRUE );
02416 nav_filelist_set( 0, FS_FIND_NEXT );
02417 i--;
02418 }
02419 return( FALSE );
02420 }