Beispiel #1
0
s32 FS_DeleteFile( char *Path )
{
#ifdef USEATTR
	//delete attribute file
	char *AttrFile = (char*)heap_alloc_aligned( 0, 0x80, 0x40 );

	_sprintf( AttrFile, "%s.attr", Path );
	f_unlink( AttrFile );
	heap_free( 0, AttrFile );
#endif
	switch( f_unlink( Path ) )
	{
		case FR_DENIED:	//Folder is not empty and can't be removed without deleting the content first	
			return FS_Delete( Path );

		case FR_OK:
			return FS_SUCCESS;

		case FR_EXIST:
			return FS_EEXIST2;

		case FR_NO_FILE:
		case FR_NO_PATH:
			return FS_ENOENT2;
		default:
			break;
	}

	return FS_EFATAL;
}
/**
  * @brief  file_scan处理非递归过程,
	*					删除旧的playlist(用于存储歌曲路径,用于文件定位)和lcdlist(用于存储歌曲列表,用于显示)
  * @param  path:初始扫描路径
  * @retval none
  */
static void file_scan(char* path)
{ 
	
  fres = f_unlink("0:mp3player/playlist.txt");//删除旧的playlist
	fres = f_unlink("0:mp3player/lcdlist.txt");	//删除旧的playlist
	fres = scan_files(path);				//递归扫描歌曲文件
}
Beispiel #3
0
s32 FS_Delete( char *Path )
{
//	dbgprintf("FS_Delete(\"%s\")\n", Path );

	char *FilePath = (char*)heap_alloc_aligned( 0, 0x80, 0x40 );

	//normal clean up
	DIR d;
	if( f_opendir( &d, Path ) == FR_OK )
	{
		FILINFO FInfo;
		
		s32 res = f_readdir( &d, &FInfo );

		if( res != FR_OK )
		{
			heap_free( 0, FilePath );
			return FS_EFATAL;
		}

		while( res == FR_OK )
		{
			memset32( FilePath, 0, 0x40 );
			strcpy( FilePath, Path );

			//insert slash
			FilePath[strlen(Path)] = '/';

			if( FInfo.lfsize )
			{
				//dbgprintf("\"%s\"\n", FInfo.lfname );
				memcpy( FilePath+strlen(Path)+1, FInfo.lfname, strlen(FInfo.lfname) );
			} else {
				//dbgprintf("\"%s\"\n", FInfo.fname );
				memcpy( FilePath+strlen(Path)+1, FInfo.fname, strlen(FInfo.fname) );
			}

			res = f_unlink( FilePath );
			if( res  != FR_OK )
			{
				//dbgprintf("\"%s\":%d\n", FilePath, res );
				if( FInfo.fattrib&AM_DIR )
				{
					FS_Delete( FilePath );
					f_unlink( FilePath );
				} else {
					heap_free( 0, FilePath );
					return FS_EFATAL;
				}
			}

			res = f_readdir( &d, &FInfo );
		}
	}

	heap_free( 0, FilePath );

	return FS_SUCCESS;
}
Beispiel #4
0
void configStart() {
	// Load the config from EEPROM
	readConfigFromEEPROM();

	// Check for config file on SD card
	FRESULT fr = f_stat("config.txt", NULL);
	switch (fr) {
	case FR_OK:
		// Config file exists
		break;
	case FR_NO_FILE:
		// Config file does not exist, create default
		readConfigDefault();
		writeConfigToFile();
		break;
	default:
		// Unknown file read error
		error(ERROR_READ_CONFIG);
	}

	fr = f_stat(converterFn, NULL);
	switch (fr) {
	case FR_OK:
		// Converter file exists
		break;
	case FR_NO_FILE:
		// Create exe file from binary
		writeConverterToFile();
		break;
	default:
		// Unknown file read error
		f_unlink(converterFn);
		error(ERROR_READ_CONFIG);
	}

	fr = f_stat(userGuideFn, NULL);
	switch (fr) {
	case FR_OK:
		// User Guide file exists
		break;
	case FR_NO_FILE:
		writeUserGuideToFile();
		break;
	default:
		// Unknown file read error
		f_unlink(userGuideFn);
		error(ERROR_READ_CONFIG);
	}

	// Read config file from card
	readConfigFromFile();

	// Write config back to card
	writeConfigToFile();

	// Update the config back to EEPROM
	writeConfigToEEPROM();
}
bool TestExtOpenssl::test_openssl_pkey_export_to_file() {
  const char *tmp = "test/test_pkey.tmp";
  f_unlink(tmp);
  VS(f_file_get_contents(tmp), false);

  Variant privkey = f_openssl_pkey_new();
  VERIFY(!privkey.isNull());
  f_openssl_pkey_export_to_file(privkey, tmp, "1234");

  VERIFY(f_file_get_contents(tmp).toString().size() > 400);
  f_unlink(tmp);
  return Count(true);
}
bool TestExtOpenssl::test_openssl_csr_export_to_file() {
  Variant csr = f_openssl_csr_new(null, null);
  VERIFY(!csr.isNull());

  const char *tmp = "test/test_csr.tmp";
  f_unlink(tmp);
  VS(f_file_get_contents(tmp), false);
  f_openssl_csr_export_to_file(csr, tmp);
  VERIFY(f_file_get_contents(tmp).toString().size() > 400);
  f_unlink(tmp);

  return Count(true);
}
bool TestExtOpenssl::test_openssl_pkcs12_export_to_file() {
  Variant privkey = f_openssl_pkey_new();
  VERIFY(!privkey.isNull());
  Variant csr = f_openssl_csr_new(null, privkey);
  VERIFY(!csr.isNull());
  Variant scert = f_openssl_csr_sign(csr, null, privkey, 365);

  const char *tmp = "test/test_pkcs12.tmp";
  f_unlink(tmp);
  VS(f_file_get_contents(tmp), false);
  f_openssl_pkcs12_export_to_file(scert, tmp, privkey, "1234");
  VERIFY(f_file_get_contents(tmp).toString().size() > 400);
  f_unlink(tmp);
  return Count(true);
}
bool TestExtOpenssl::test_openssl_pkcs7_encrypt() {
  Variant privkey = f_openssl_pkey_new();
  VERIFY(!privkey.isNull());
  Variant csr = f_openssl_csr_new(null, privkey);
  VERIFY(!csr.isNull());
  Variant scert = f_openssl_csr_sign(csr, null, privkey, 365);
  Variant pubkey = f_openssl_csr_get_public_key(csr);
  VERIFY(!pubkey.isNull());

  String data = "some secret data";
  const char *infile = "test/test_pkcs7.in";
  const char *outfile = "test/test_pkcs7.out";
  f_unlink(infile);
  f_unlink(outfile);
  f_file_put_contents(infile, data);

  VERIFY(f_openssl_pkcs7_encrypt
         (infile, outfile, scert,
          CREATE_MAP2("To", "*****@*****.**","From", "*****@*****.**")));

  f_unlink(infile);
  VERIFY(f_openssl_pkcs7_decrypt(outfile, infile, scert, privkey));
  Variant decrypted = f_file_get_contents(infile);
  f_var_dump(decrypted);
  f_unlink(infile);
  f_unlink(outfile);
  /*
   * PHP didn't work either:

    $privkey = openssl_pkey_new();
    $csr = openssl_csr_new(array(), $privkey);
    $scert = openssl_csr_sign($csr, null, $privkey, 365);

    $data = "some secret data";
    $infile = "test_pkcs7.in";
    $outfile = "test_pkcs7.out";
    file_put_contents($infile, $data);

    openssl_pkcs7_encrypt($infile, $outfile, $scert,
                          array("To" => "*****@*****.**",
                                "From" => "*****@*****.**"));

    var_dump(openssl_pkcs7_decrypt($outfile, $infile, $scert, $privkey));
    $decrypted = file_get_contents($infile);var_dump($decrypted);

   */
  return Count(true);
}
Beispiel #9
0
s32 FS_Move( char *sPath, char *dPath )
{
	switch( f_rename( sPath, dPath ) )
	{
		case FR_OK:
			return FS_SUCCESS;

		case FR_NO_PATH:
		case FR_NO_FILE:
			return FS_ENOENT2;

		case FR_EXIST:	//On normal IOS Rename overwrites the target!
			if( f_unlink( dPath ) == FR_OK )
			{
				if( f_rename( sPath, dPath ) == FR_OK )
				{
					return FS_SUCCESS;
				}
			}
		default:
			break;
	}

	return FS_EFATAL;
}
Beispiel #10
0
/*******************************************************************************
  * @函数名称		dir_totle
  * @函数说明		计算文件夹的总数,多余的将其删除
  * @输入参数		路径结构体指针、文件信息结构体指针
  * @输出参数		无
  * @返回参数		文件夹的总数
*******************************************************************************/
uint16_t dir_totle(DIR *path, FILINFO* file_info){
    
    uint16_t dir_num = 0;
    static TCHAR *fn;
    while(1){
        
        if(f_readdir(path,file_info) == FR_OK){
            
            if (file_info->fname[0] == 0) break;
            
            if(file_info->fattrib == AM_DIR){
                
                dir_num++;
#if _USE_LFN
                fn = *file_info->lfname ? file_info->lfname : file_info->fname;
#else
                fn = file_info->fname;
#endif
                if(!Queue_Push(&Q_dir,fn)){
                    /* first pop */
                    msg_t *delete_file;
                    delete_file = Queue_Pop(&Q_dir);
                    f_unlink((const TCHAR*)delete_file->buf);
                    memset(delete_file->buf,0,sizeof(delete_file->buf));
                    
                    /* next push */
                    memcpy(Q_dir.m_Msg[Q_dir.rear].buf,fn,C_MAX_BUF_SIZE);
                    Q_dir.next = Q_dir.rear;
                    Q_dir.rear = (Q_dir.rear + 1) % Q_dir.totle_num;
                }
            }
        }
    }
    return dir_num;
}
bool TestExtFile::test_unlink() {
  f_touch("test/test_ext_file.tmp");
  VERIFY(f_file_exists("test/test_ext_file.tmp"));
  f_unlink("test/test_ext_file.tmp");
  VERIFY(!f_file_exists("test/test_ext_file.tmp"));
  return Count(true);
}
Beispiel #12
0
void LTK_delete_file(void)
{
    FATFS fs;
    FRESULT res;
    uint8_t name[16] = {0};
    printf("please input the file name that you want to delete\n");
    scanf("%[^\n]",name);
    res = f_mount(0,&fs);
    if (res != FR_OK)
    {
        printf("mont file system error, error code: %u\n",res);
        return;
    }
    res = f_unlink((TCHAR *)name);

    if (res == FR_OK)
    {
        printf("file deleted successfully!\n");
    }
    else if (res == FR_NO_FILE)
    {
        printf("no such file or directory\n");
    }
    else if (res == FR_NO_PATH)
    {
        printf("no such path\n");
    }
    else
    {
        printf("error code: %u\n",res);
    }
    f_mount(0,NULL);
}
Beispiel #13
0
void writeConverterToFile() {
	FIL converter;
	if (f_open(&converter, converterFn, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) {
		f_unlink(converterFn);
		error(ERROR_WRITE_CONFIG);
	}

	uint32_t writtenBytes;
	f_write(&converter, consoleConverterBinary, sizeof(consoleConverterBinary), &writtenBytes);
	f_close(&converter);

	if(writtenBytes != sizeof(consoleConverterBinary)){
		f_unlink(converterFn);
		error(ERROR_WRITE_CONFIG);
	}
}
Beispiel #14
0
void writeUserGuideToFile() {
	FIL userGuide;
	if (f_open(&userGuide, userGuideFn, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) {
		f_unlink(userGuideFn);
		error(ERROR_WRITE_CONFIG);
	}

	uint32_t writtenBytes;
	f_write(&userGuide, userGuideText, sizeof(userGuideText)-1, &writtenBytes);
	f_close(&userGuide);

	if(writtenBytes != sizeof(userGuideText)-1){
		f_unlink(userGuideFn);
		error(ERROR_WRITE_CONFIG);
	}
}
Beispiel #15
0
/**
 * @brief einzelen Datei löschen
 * @param Name der Datei
 * @param Dateityo (1 oder 2)
 */
void delete_file(int fileID, int type){

	SetCurrentFileID(fileID, type);
	if(FileExists(fileID) == 1) f_unlink((char*) sdcFilename);


}
Beispiel #16
0
int dfs_elm_unlink(struct dfs_filesystem *fs, const char *path)
{
	FRESULT result;

#if _VOLUMES > 1
	int vol;
	char *drivers_fn;
	extern int elm_get_vol(FATFS *fat);

	/* add path for ELM FatFS driver support */
	vol = elm_get_vol((FATFS *)fs->data);
	if (vol < 0)
		return -DFS_STATUS_ENOENT;
	drivers_fn = rt_malloc(256);
	if (drivers_fn == RT_NULL)
		return -DFS_STATUS_ENOMEM;

	rt_snprintf(drivers_fn, 256, "%d:%s", vol, path);
#else
	const char *drivers_fn;
	drivers_fn = path;
#endif

	result = f_unlink(drivers_fn);
#if _VOLUMES > 1
	rt_free(drivers_fn);
#endif
	return elm_result_to_dfs(result);
}
Beispiel #17
0
int fatfs_unlink(vnode_t * dir, const char * name)
{
    struct fatfs_sb * ffsb = get_ffsb_of_sb(dir->sb);
    struct fatfs_inode * indir = get_inode_of_vnode(dir);
    char * in_fpath;
    FRESULT err;
    int retval;

    if (!S_ISDIR(dir->vn_mode))
        return -ENOTDIR;

    in_fpath = format_fpath(indir, name);
    if (!in_fpath)
        return -ENOMEM;

    /* TODO May need checks if file/dir is opened */

    err = f_unlink(&ffsb->ff_fs, in_fpath);
    if (err)
        retval = fresult2errno(err);
    else
        retval = 0;

    kfree(in_fpath);
    return retval;
}
Beispiel #18
0
int dihapus(char * nama) {
	FRESULT res;
	int flag=10;
	char namanya[255];
	
	strcpy(namanya, nama);
	//printf("_______NAMANYA : %s",nama);
	//return 0;
	res = f_unlink(namanya);
	if (res == FR_OK) {
		printf("......dihapus\r\n");
		return 0;
	} 
	if (res == FR_WRITE_PROTECTED) {
		printf("......FR_WRITE_PROTECTED\r\n");
		flag= -2;
	}
	if (res == FR_NO_FILE) {
		printf("......FR_NO_FILE\r\n");
		flag= -2; 
	}
	if (res == FR_NO_PATH) {
		printf("......FR_NO_PATH\r\n");
		flag= -2; 
	}
	if (res == FR_INVALID_NAME) {
		printf("......FR_INVALID_NAME\r\n");
		flag= -2; 
	}
	if (res == FR_DENIED) {
		printf("......FR_DENIED\r\n");
		flag= -1; 
	}
	return flag;
}
Beispiel #19
0
/**
 * @brief Remove a directory
 */
bool CFile::rmDir()
{
    bool rc = false;
    if ( f_unlink(mPath.data()) == FR_OK )
        rc = true;
    return rc;
}
Beispiel #20
0
void check_sd_firmware()
{
	int r;
	printf("Check SD\n");
	f_mount(0, &fat);
	if ((r = f_open(&file, firmware_file, FA_READ)) == FR_OK)
	{
		printf("Flashing firmware...\n");
		uint8_t buf[512];
		unsigned int r = sizeof(buf);
		uint32_t address = USER_FLASH_START;
		while (r == sizeof(buf))
		{
			if (f_read(&file, buf, sizeof(buf), &r) != FR_OK)
			{
				f_close(&file);
				return;
			}

			setleds((address - USER_FLASH_START) >> 15);

			printf("\t0x%lx\n", address);

			write_flash((void *) address, (char *)buf, sizeof(buf));
			address += r;
		}
		f_close(&file);
		if (address > USER_FLASH_START)
		{
			printf("Complete!\n");
			r = f_unlink(firmware_old);
			r = f_rename(firmware_file, firmware_old);
		}
	}
Beispiel #21
0
void delete_file(char *fname)
{
	FRESULT res;
	res = f_unlink(fname);
	if(res != FR_OK)
		printf("Error deleting file:%u\r\n", res);
	return;
}
Beispiel #22
0
static void CreateSqliteTestTable() {
  f_unlink("/tmp/foo.db");
  p_SQLite3 db(NEWOBJ(c_SQLite3)());
  db->t_open("/tmp/foo.db");
  db->t_exec("CREATE TABLE foo (bar STRING)");
  db->t_exec("INSERT INTO foo VALUES ('ABC')");
  db->t_exec("INSERT INTO foo VALUES ('DEF')");
}
bool TestExtOpenssl::test_openssl_x509_export_to_file() {
  Variant fcert = f_file_get_contents("test/test_x509.crt");
  Variant cert = f_openssl_x509_read(fcert);

  const char *tmp = "test/test_x509.tmp";
  f_unlink(tmp);
  VS(f_file_get_contents(tmp), false);
  VERIFY(f_openssl_x509_export_to_file(cert, tmp));

  Variant fcert2 = f_file_get_contents(tmp);
  Variant cert2 = f_openssl_x509_read(fcert2);
  Variant info = f_openssl_x509_parse(cert2);
  VS(info["subject"]["O"], "RSA Data Security, Inc.");

  f_unlink(tmp);
  return Count(true);
}
Beispiel #24
0
int FATFileSystem::remove(const char *filename) {
    FRESULT res = f_unlink(filename);
    if (res) {
        debug_if(FFS_DBG, "f_unlink() failed: %d\n", res);
        return -1;
    }
    return 0;
}
Beispiel #25
0
/*******************************************************************************
* Function Name  : Test_f_deldir
* Description    : 删除目录
* Input          : 
* Return         : res
*******************************************************************************/
FRESULT Test_f_deldir(const TCHAR* path)//删除一个目录,输入目录的路径;目录里的内容是空的才能删除Test_f_deldir("/dir");	
{
   
		
		fatfs_res=f_unlink(path);//删除一个目录

		return fatfs_res;
}
/*
 *  ======== rmdir ========
 */
int rmdir(const char * path)
{
    if (f_unlink(path) == FR_OK) {
        return (0);
    }
    else {
        return (-1);
    }
}
Beispiel #27
0
static int _unlink(vfs_mount_t *mountp, const char *name)
{
    fatfs_desc_t *fs_desc = (fatfs_desc_t *)mountp->private_data;

    snprintf(fs_desc->abs_path_str_buff, FATFS_MAX_ABS_PATH_SIZE, "%d:/%s",
             fs_desc->vol_idx, name);

    return fatfs_err_to_errno(f_unlink(fs_desc->abs_path_str_buff));
}
Beispiel #28
0
void gui_set_debug_delete_fc(uint8_t ret)
{
	if (ret == GUI_DIALOG_YES)
	{
		assert(f_unlink(DEBUG_FILE) == FR_OK);
	}

	gui_switch_task(GUI_SET_DEBUG);
}
bool TestExtFile::test_chown() {
  Variant f = f_fopen("test/test_ext_file.tmp", "w");
  f_fputs(f, "testing\nchown\n");
  f_fclose(f);
  VERIFY(f_chmod("test/test_ext_file.txt", 0777));
  //VERIFY(f_chown("test/test_ext_file.tmp", "hzhao"));
  f_unlink("test/test_ext_file.tmp");
  return Count(true);
}
bool TestExtFile::test_linkinfo() {
  if (f_file_exists("test/test_ext_file2.tmp")) {
    f_unlink("test/test_ext_file2.tmp");
    VERIFY(!f_file_exists("test/test_ext_file2.tmp"));
  }
  f_touch("test/test_ext_file.tmp");
  f_symlink("test/test_ext_file.tmp", "test/test_ext_file2.tmp");
  VERIFY(more(f_linkinfo("test/test_ext_file2.tmp"), 0));
  return Count(true);
}