forked from KolibriOS/kolibrios
897 lines
20 KiB
C
897 lines
20 KiB
C
/*
|
|
2015
|
|
Author: Pavel Yakovlev.
|
|
*/
|
|
|
|
#define LIB_NAME "fs"
|
|
|
|
#include "coff.h"
|
|
#include <kolibri.c>
|
|
#include <stdlib.c>
|
|
|
|
|
|
//char _PATH_[4096];
|
|
char *_PATH_;
|
|
dword *_ADR_ = 32;
|
|
char *FS_SELF_PATH;
|
|
char *FS_SELF_DIR=0;
|
|
|
|
char TMP1[4096] = {0};
|
|
char TMP2[4096] = {0};
|
|
|
|
static void*(* _stdcall pointer_callback_copy)(void);
|
|
static void*(* _stdcall pointer_callback_move)(void);
|
|
static void*(* _stdcall pointer_callback_remove)(void);
|
|
|
|
#pragma pack(push,1)
|
|
typedef struct
|
|
{
|
|
unsigned p00;
|
|
unsigned p04;
|
|
unsigned p08;
|
|
unsigned p12;
|
|
unsigned p16;
|
|
char p20;
|
|
char *p21;
|
|
} FS_struct70;
|
|
#pragma pack(pop)
|
|
|
|
#pragma pack(push,1)
|
|
typedef struct
|
|
{
|
|
unsigned p00;
|
|
char p04;
|
|
char p05[3];
|
|
unsigned p08;
|
|
unsigned p12;
|
|
unsigned p16;
|
|
unsigned p20;
|
|
unsigned p24;
|
|
unsigned p28;
|
|
//unsigned p32[2];
|
|
long long p32;
|
|
unsigned p40;
|
|
} FS_struct_BDVK;
|
|
#pragma pack(pop)
|
|
|
|
#define FS_COPY_BUFFER_SET 0x100000
|
|
static inline char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
|
|
|
|
static inline char *string_error_code(char code)
|
|
{
|
|
if(!code)return "Successfully!";
|
|
if(code==1)return "Not defined basis and / or hard disk partition (sub-functions 7, 8 function 21)!";
|
|
if(code==2)return "Function is not supported for this file system!";
|
|
if(code==3)return "Unknown file system!";
|
|
if(code==4)return "Reserved, never returned to the current implementation!";
|
|
if(code==5)return "File not found!";
|
|
if(code==6)return "The file is ended!";
|
|
if(code==7)return "Pointer out the application memory!";
|
|
if(code==8)return "Disk is full!";
|
|
if(code==9)return "FAT table is destroyed!";
|
|
if(code==10)return "Access is denied!";
|
|
if(code==11)return "Device error!";
|
|
return "An unexpected error!";
|
|
}
|
|
|
|
static inline dword sprintf(char *mstr,const char *fmt,...)
|
|
{
|
|
|
|
dword *arg = &fmt;
|
|
char *tmp = 0;
|
|
char *pos = mstr;
|
|
--pos;
|
|
--fmt;
|
|
while(*++fmt)
|
|
{
|
|
char s = *fmt;
|
|
if(s=='%')
|
|
{
|
|
s = *++fmt;
|
|
if(s=='s')
|
|
{
|
|
tmp = *++arg;
|
|
while(*tmp)*++pos = *tmp++;
|
|
}
|
|
else
|
|
{
|
|
*++pos='%';
|
|
--fmt;
|
|
}
|
|
}
|
|
else *++pos=s;
|
|
}
|
|
*++pos = 0;
|
|
return pos-mstr;
|
|
}
|
|
|
|
static inline int FS_file_70(FS_struct70 *k)
|
|
{
|
|
asm volatile ("int $0x40"::"a"(70), "b"(k));
|
|
}
|
|
|
|
FS_struct_BDVK ret_struct;
|
|
static inline char get_bdvk(char *path)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 5;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = 0;
|
|
file_read_struct.p16 = (unsigned)&ret_struct;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
return FS_file_70(&file_read_struct);
|
|
//return (FS_struct_BDVK*)&ret_struct;
|
|
}
|
|
|
|
static inline char set_bdvk(char *path,FS_struct_BDVK *bdvk)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 6;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = 0;
|
|
file_read_struct.p16 = bdvk;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
return FS_file_70(&file_read_struct);
|
|
}
|
|
|
|
static inline long long file_size(char *path)
|
|
{
|
|
FS_struct_BDVK *data = get_bdvk(path);
|
|
return data->p32;
|
|
}
|
|
|
|
static inline byte file_isdir(char *path)
|
|
{
|
|
FS_struct_BDVK *data = get_bdvk(path);
|
|
if(data->p00&0b10000)return 1;
|
|
return 0;
|
|
}
|
|
|
|
static inline byte file_ismetka(char *path)
|
|
{
|
|
FS_struct_BDVK *data = get_bdvk(path);
|
|
if(data->p00&0b1000)return 1;
|
|
return 0;
|
|
}
|
|
|
|
static inline byte file_isfile()
|
|
{
|
|
//FS_struct_BDVK *data = get_bdvk(path);
|
|
if(ret_struct.p00&0b11000)return 0;
|
|
return 1;
|
|
}
|
|
|
|
static inline int file_run(char *path,char *arg)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 7;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = arg;
|
|
file_read_struct.p12 = 0;
|
|
file_read_struct.p16 = 0;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
return FS_file_70(&file_read_struct);
|
|
|
|
}
|
|
|
|
static inline int file_read_binary(char *path,unsigned pos,unsigned size,void *adr)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 0;
|
|
file_read_struct.p04 = pos;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = size;
|
|
file_read_struct.p16 = (unsigned)adr;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
char c = FS_file_70(&file_read_struct);
|
|
if(c)
|
|
{
|
|
sprintf(&BUF_COPY,"'Error read file (%s) file: %s.'E",string_error_code(c),path);
|
|
file_run("/sys/@notify",&BUF_COPY);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static inline int file_delete(char *path)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 8;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = 0;
|
|
file_read_struct.p16 = 0;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
char c = FS_file_70(&file_read_struct);
|
|
if(c)
|
|
{
|
|
sprintf(&BUF_COPY,"'Error delete file: %s. Info: %s'E",string_error_code(c),path);
|
|
file_run("/sys/@notify",&BUF_COPY);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static inline int file_mkdir(char *path)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 9;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = 0;
|
|
file_read_struct.p16 = 0;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
char c = FS_file_70(&file_read_struct);
|
|
if(c)
|
|
{
|
|
sprintf(&BUF_COPY,"'Error make dir: %s. Info: %s.'E",string_error_code(c),path);
|
|
file_run("/sys/@notify",&BUF_COPY);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static inline int file_write(char *path,void *ukaz,dword size)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 2;
|
|
file_read_struct.p04 = 0;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = size;
|
|
file_read_struct.p16 = ukaz;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
char c = FS_file_70(&file_read_struct);
|
|
if(c)
|
|
{
|
|
sprintf(&BUF_COPY,"'Error write file: %s. Info: %s.'E",string_error_code(c),path);
|
|
file_run("/sys/@notify",&BUF_COPY);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static inline int file_rewrite(char *path,dword pos1,dword pos2,void *ukaz,dword size)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 3;
|
|
file_read_struct.p04 = pos1;
|
|
file_read_struct.p08 = pos2;
|
|
file_read_struct.p12 = size;
|
|
file_read_struct.p16 = ukaz;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = path;
|
|
char c = FS_file_70(&file_read_struct);
|
|
if(c)
|
|
{
|
|
sprintf(&BUF_COPY,"'Error rewrite file (%s) file: %s.'E",string_error_code(c),path);
|
|
file_run("/sys/@notify",&BUF_COPY);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
|
|
static inline char file_copy(char *path1,char *path2)
|
|
{
|
|
long long size = file_size(path1);
|
|
if(!size)file_write(path2,&BUF_COPY,0);
|
|
long long cel = size;
|
|
cel /= FS_COPY_BUFFER_SET;
|
|
dword ost = size-cel*FS_COPY_BUFFER_SET;
|
|
long long i = 0;
|
|
char err=0;
|
|
if(cel)
|
|
{
|
|
if(file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
|
|
if(file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
|
|
++i;
|
|
}
|
|
else
|
|
{
|
|
if(file_read_binary(path1,0,ost,&BUF_COPY))goto ERROR;
|
|
if(file_write(path2,&BUF_COPY,ost))goto ERROR;
|
|
return 1;
|
|
}
|
|
while(i<cel)
|
|
{
|
|
if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
|
|
if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
|
|
++i;
|
|
}
|
|
if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY))goto ERROR;
|
|
if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost))goto ERROR;
|
|
return 1;
|
|
ERROR:
|
|
|
|
//asm("":"=a"(err));
|
|
//sprintf(&BUF_COPY,"Error %s file: %s.",string_error_code(err),path1);
|
|
//file_run("/sys/@notify",&BUF_COPY);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
dword FS_COPY_BUFFER_SET_POINT = 0x100000;
|
|
dword BUF_COPY_POINT = 0;
|
|
static inline char file_copy(char *path1,char *path2)
|
|
{
|
|
long long size = file_size(path1);
|
|
if(!size)file_write(path2,BUF_COPY_POINT,0);
|
|
long long cel = size;
|
|
cel /= FS_COPY_BUFFER_SET_POINT;
|
|
dword ost = size-cel*FS_COPY_BUFFER_SET_POINT;
|
|
long long i = 0;
|
|
char err=0;
|
|
if(cel)
|
|
{
|
|
if(file_read_binary(path1,0,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
|
|
if(file_write(path2,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
|
|
++i;
|
|
}
|
|
else
|
|
{
|
|
if(file_read_binary(path1,0,ost,BUF_COPY_POINT))goto ERROR;
|
|
if(file_write(path2,BUF_COPY_POINT,ost))goto ERROR;
|
|
return 1;
|
|
}
|
|
while(i<cel)
|
|
{
|
|
if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
|
|
if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
|
|
++i;
|
|
}
|
|
if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,ost,BUF_COPY_POINT))goto ERROR;
|
|
if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,ost))goto ERROR;
|
|
return 1;
|
|
ERROR:
|
|
|
|
//asm("":"=a"(err));
|
|
//sprintf(BUF_COPY_POINT,"Error %s file: %s.",string_error_code(err),path1);
|
|
//file_run("/sys/@notify",BUF_COPY_POINT);
|
|
return 0;
|
|
}
|
|
*/
|
|
/*
|
|
#define FS_COPY_BUFFER_SET 0x100000
|
|
char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
|
|
static inline char file_copy(char *path1,char *path2)
|
|
{
|
|
long long size = file_size(path1);
|
|
if(!size)file_write(path2,&BUF_COPY,0);
|
|
long long cel = size;
|
|
cel /= FS_COPY_BUFFER_SET;
|
|
dword ost = size-cel*FS_COPY_BUFFER_SET;
|
|
long long i = 0;
|
|
|
|
if(cel)
|
|
{
|
|
file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY);
|
|
file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET);
|
|
++i;
|
|
}
|
|
else
|
|
{
|
|
file_read_binary(path1,0,ost,&BUF_COPY);
|
|
file_write(path2,&BUF_COPY,ost);
|
|
return 1;
|
|
}
|
|
while(i<cel)
|
|
{
|
|
file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY);
|
|
file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET);
|
|
++i;
|
|
}
|
|
file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY);
|
|
file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost);
|
|
return 1;
|
|
}
|
|
*/
|
|
long long size_long_file=0;
|
|
|
|
static inline void *file_read(char *path)
|
|
{
|
|
size_long_file = file_size(path);
|
|
void *data = malloc(size_long_file+1);
|
|
|
|
if(file_read_binary(path,0,size_long_file,data))return 0;
|
|
|
|
return data;
|
|
}
|
|
|
|
static inline void *file_readKPACK(char *path)
|
|
{
|
|
void *data = 0;
|
|
dword size=0;
|
|
asm ("int $0x40":"=a"(data),"=d"(size):"a"(68), "b"(27), "c"(path));
|
|
size_long_file = size;
|
|
asm volatile(""::"c"(size));
|
|
return data;
|
|
}
|
|
|
|
static inline int file_read_dir(dword begin,dword file_count,dword read_buffer,char *dir_path)
|
|
{
|
|
FS_struct70 file_read_struct;
|
|
file_read_struct.p00 = 1;
|
|
file_read_struct.p04 = begin;
|
|
file_read_struct.p08 = 0;
|
|
file_read_struct.p12 = file_count;
|
|
file_read_struct.p16 = read_buffer;
|
|
file_read_struct.p20 = 0;
|
|
file_read_struct.p21 = dir_path;
|
|
return FS_file_70(&file_read_struct);
|
|
}
|
|
|
|
|
|
static inline byte strncmp(char *s1,const char *s2, dword n)
|
|
{
|
|
while(n)
|
|
{
|
|
if(*s1!=*s2)return *s1-*s2;
|
|
++s1;
|
|
++s2;
|
|
--n;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char *strdup(char *str)
|
|
{
|
|
char *r = malloc(strlen(str));
|
|
strcpy(r,str);
|
|
return r;
|
|
}
|
|
|
|
char *self_get_dir(void)
|
|
{
|
|
if(!FS_SELF_DIR)
|
|
{
|
|
FS_SELF_DIR = malloc(4096);
|
|
//FS_SELF_PATH = malloc(4096);
|
|
//strcpy(FS_SELF_PATH,*_ADR_);
|
|
FS_SELF_PATH = *_ADR_;
|
|
int pos=0;
|
|
int tmp=0;
|
|
|
|
while(FS_SELF_PATH[pos])
|
|
{
|
|
FS_SELF_DIR[pos] = FS_SELF_PATH[pos];
|
|
if(FS_SELF_PATH[pos]=='/')tmp = pos;
|
|
++pos;
|
|
}
|
|
if(tmp)pos=tmp;
|
|
FS_SELF_DIR[pos]=0;
|
|
}
|
|
return FS_SELF_DIR;
|
|
}
|
|
|
|
|
|
char *get_full_path(char *path)
|
|
{
|
|
self_get_dir();
|
|
if(!path) return FS_SELF_DIR;
|
|
char *pos = path;
|
|
if(!_PATH_) _PATH_ = malloc(4096);
|
|
if(*pos=='/')
|
|
{
|
|
++pos;
|
|
if(!strncmp(pos,"sys/",4)) return path;
|
|
if(!strncmp(pos,"kolibrios/",10)) return path;
|
|
if(!strncmp(pos,"rd/",3)) return path;
|
|
if(!strncmp(pos,"fd/",3)) return path;
|
|
if(!strncmp(pos,"cd",2)) return path;
|
|
if(!strncmp(pos,"hd",2)) return path;
|
|
if(!strncmp(pos,"bd",2)) return path;
|
|
if(!strncmp(pos,"tmp",3)) return path;
|
|
if(!strncmp(pos,"usbhd",5)) return path;
|
|
if(!*pos)return path;
|
|
strcpy(_PATH_,"/sys");
|
|
strcpy(_PATH_+4,path);
|
|
return _PATH_;
|
|
}
|
|
if(!strncmp(path,"./",2)) return path;
|
|
sprintf(_PATH_,"%s/%s",FS_SELF_DIR,path);
|
|
return _PATH_;
|
|
}
|
|
|
|
long long FS_LENGHT=0;
|
|
|
|
dword *__BUF__COUNT__ = 0;
|
|
int COUNT_FILE = 0;
|
|
int _get_entries_count(char *path)
|
|
{
|
|
//char BUF[32];
|
|
if(!__BUF__COUNT__)__BUF__COUNT__=malloc(32);
|
|
if(!file_read_dir(0,0, __BUF__COUNT__, path))
|
|
{
|
|
if(strcmp(path,"/"))COUNT_FILE = *(__BUF__COUNT__+2)-2;
|
|
else COUNT_FILE = *(__BUF__COUNT__+2);
|
|
return COUNT_FILE;
|
|
}
|
|
COUNT_FILE = -1;
|
|
return -1;
|
|
}
|
|
|
|
int get_entries_count(char *path)
|
|
{
|
|
return _get_entries_count(get_full_path(path));
|
|
}
|
|
|
|
dword _get_dir_info(char *path)
|
|
{
|
|
_get_entries_count(path);
|
|
if(!strcmp(path,"/"))
|
|
{
|
|
if(COUNT_FILE==-1)return 0;
|
|
dword buffer = malloc(304*COUNT_FILE+72);
|
|
file_read_dir(0,COUNT_FILE,buffer,path);
|
|
return buffer;
|
|
}
|
|
if(COUNT_FILE==-1)return 0;
|
|
dword buffer = malloc(304*COUNT_FILE+72);
|
|
file_read_dir(2,COUNT_FILE+2,buffer,path);
|
|
return buffer;
|
|
}
|
|
|
|
dword get_dir_info(char *path)
|
|
{
|
|
return _get_dir_info(get_full_path(path));
|
|
}
|
|
|
|
dword get_dir_position(dword a,dword i)
|
|
{
|
|
return i*344+32+a;
|
|
}
|
|
|
|
char *get_file_name(void *args)
|
|
{
|
|
return args+40;
|
|
}
|
|
|
|
char BUF_HEADER[5]={0};
|
|
dword read(char *path)
|
|
{
|
|
dword *adr = &BUF_HEADER;
|
|
path = get_full_path(path);
|
|
file_read_binary(path,0,4,adr);
|
|
if(*adr=='KCPK') return file_readKPACK(path);
|
|
dword ret = file_read(path);
|
|
//FS_LENGHT = size_long_file;
|
|
asm volatile(""::"c"((long)size_long_file));
|
|
return ret;
|
|
}
|
|
|
|
|
|
dword quantity_dir = 0,quantity_file = 0;
|
|
long long fs_size_global = 0;
|
|
long long LOOP_SIZE(char *path)
|
|
{
|
|
dword tmp_len = file_size(path);
|
|
if(ret_struct.p00&0b10000)
|
|
{
|
|
++quantity_dir;
|
|
dword tmp_buf = get_dir_info(path);
|
|
if(COUNT_FILE<1) return 0;
|
|
|
|
char *new_path_file = malloc(4096);
|
|
int tmp_count = COUNT_FILE;
|
|
int i = 0;
|
|
fs_size_global = 0;
|
|
while(i<tmp_count)
|
|
{
|
|
sprintf(new_path_file,"%s/%s",path,304*i+tmp_buf+72);
|
|
fs_size_global += LOOP_SIZE(new_path_file);
|
|
++i;
|
|
}
|
|
free(tmp_buf);
|
|
free(new_path_file);
|
|
return fs_size_global;
|
|
}
|
|
++quantity_file;
|
|
return tmp_len;
|
|
}
|
|
|
|
dword get_size(char *path)
|
|
{
|
|
quantity_dir = 0;
|
|
quantity_file = 0;
|
|
long long size = LOOP_SIZE(get_full_path(path));
|
|
if(quantity_dir>0)--quantity_dir;
|
|
asm volatile(""::"c"(quantity_dir),"d"(quantity_file));
|
|
return (dword)size;
|
|
}
|
|
|
|
/*
|
|
char set_attributes_loop(char *path,dword strucs)
|
|
{
|
|
if(get_bdvk(path))return 0;
|
|
dword tmp = (ret_struct.p00^strucs)&0b111;
|
|
ret_struct.p00=(tmp^ret_struct.p00)^0xFFFFFFFF;
|
|
if(ret_struct.p00&0b10000)
|
|
{
|
|
dword tmp_buf = _get_dir_info(path);
|
|
if(!COUNT_FILE) goto END;
|
|
|
|
char *new_path_file = malloc(4096);
|
|
int tmp_count = COUNT_FILE;
|
|
int i = 0;
|
|
char *position = tmp_buf+72;
|
|
while(i<tmp_count)
|
|
{
|
|
sprintf(new_path_file,"%s/%s",path,position);
|
|
position+=304;
|
|
if(!set_attributes_loop(new_path_file,strucs))
|
|
{
|
|
free(tmp_buf);
|
|
free(new_path_file);
|
|
return 0;
|
|
}
|
|
++i;
|
|
}
|
|
free(new_path_file);
|
|
END:
|
|
free(tmp_buf);
|
|
}
|
|
if(set_bdvk(path,&ret_struct))return 0;
|
|
return 1;
|
|
}
|
|
|
|
char set_attributes(char *path,dword strucs,char cmd)
|
|
{
|
|
if(cmd)return set_attributes_loop(get_full_path(path),strucs);
|
|
|
|
}
|
|
*/
|
|
|
|
char remove_loop(char *path)
|
|
{
|
|
if(get_bdvk(path))return 0;
|
|
if(ret_struct.p00&0b10000)
|
|
{
|
|
dword tmp_buf = _get_dir_info(path);
|
|
if(!COUNT_FILE) goto END;
|
|
|
|
char *new_path_file = malloc(4096);
|
|
int tmp_count = COUNT_FILE;
|
|
int i = 0;
|
|
char *position = tmp_buf+72;
|
|
while(i<tmp_count)
|
|
{
|
|
sprintf(new_path_file,"%s/%s",path,position);
|
|
position+=304;
|
|
if(!remove_loop(new_path_file))
|
|
{
|
|
free(tmp_buf);
|
|
free(new_path_file);
|
|
return 0;
|
|
}
|
|
++i;
|
|
}
|
|
free(new_path_file);
|
|
END:
|
|
free(tmp_buf);
|
|
}
|
|
if(file_delete(path))return 0;
|
|
return 1;
|
|
}
|
|
|
|
char remove(char *path)
|
|
{
|
|
return remove_loop(get_full_path(path));
|
|
}
|
|
|
|
int make_dir(char *path)
|
|
{
|
|
return file_mkdir(get_full_path(path));
|
|
}
|
|
|
|
char copy_loop(char *path1,char *path2)
|
|
{
|
|
if(get_bdvk(path1))return 0;
|
|
if(ret_struct.p00&0b10000)
|
|
{
|
|
file_mkdir(path2);
|
|
set_bdvk(path2,&ret_struct);
|
|
dword tmp_buf = _get_dir_info(path1);
|
|
if(!COUNT_FILE) goto END;
|
|
|
|
char *new_path_file1 = malloc(4096);
|
|
char *new_path_file2 = malloc(4096);
|
|
int tmp_count = COUNT_FILE;
|
|
int i = 0;
|
|
dword position = tmp_buf+72;
|
|
while(i<tmp_count)
|
|
{
|
|
sprintf(new_path_file1,"%s/%s",path1,position);
|
|
sprintf(new_path_file2,"%s/%s",path2,position);
|
|
if(pointer_callback_copy)
|
|
{
|
|
asm volatile(""::"c"(new_path_file1),"d"(new_path_file2));
|
|
pointer_callback_copy();
|
|
}
|
|
position+=304;
|
|
if(!copy_loop(new_path_file1,new_path_file2))
|
|
{
|
|
free(tmp_buf);
|
|
free(new_path_file1);
|
|
free(new_path_file2);
|
|
return 0;
|
|
}
|
|
++i;
|
|
}
|
|
free(new_path_file1);
|
|
free(new_path_file2);
|
|
END:
|
|
free(tmp_buf);
|
|
return 1;
|
|
}
|
|
char r = file_copy(path1,path2);
|
|
set_bdvk(path2,&ret_struct);
|
|
return r;
|
|
}
|
|
|
|
char copy(char *path1,char *path2)
|
|
{
|
|
char *tmp = get_full_path(path1);
|
|
path1 = malloc(4096);
|
|
strcpy(path1,tmp);
|
|
|
|
char *r=copy_loop(path1,get_full_path(path2));
|
|
|
|
free(path1);
|
|
return r;
|
|
}
|
|
|
|
char move_loop(char *path1,char *path2)
|
|
{
|
|
if(get_bdvk(path1))return 0;
|
|
if(ret_struct.p00&0b10000)
|
|
{
|
|
file_mkdir(path2);
|
|
set_bdvk(path2,&ret_struct);
|
|
dword tmp_buf = _get_dir_info(path1);
|
|
if(!COUNT_FILE) goto END;
|
|
|
|
char *new_path_file1 = malloc(4096);
|
|
char *new_path_file2 = malloc(4096);
|
|
int tmp_count = COUNT_FILE;
|
|
int i = 0;
|
|
dword position = tmp_buf+72;
|
|
while(i<tmp_count)
|
|
{
|
|
sprintf(new_path_file1,"%s/%s",path1,position);
|
|
sprintf(new_path_file2,"%s/%s",path2,position);
|
|
if(pointer_callback_move)
|
|
{
|
|
asm volatile(""::"c"(new_path_file1),"d"(new_path_file2));
|
|
pointer_callback_copy();
|
|
}
|
|
position+=304;
|
|
if(!move_loop(new_path_file1,new_path_file2))
|
|
{
|
|
free(tmp_buf);
|
|
free(new_path_file1);
|
|
free(new_path_file2);
|
|
return 0;
|
|
}
|
|
++i;
|
|
}
|
|
free(new_path_file1);
|
|
free(new_path_file2);
|
|
END:
|
|
free(tmp_buf);
|
|
if(file_delete(path1)) return 0;
|
|
return 1;
|
|
}
|
|
char r = 0;
|
|
if(file_copy(path1,path2)) if(!file_delete(path1))r=1;
|
|
if(r)set_bdvk(path2,&ret_struct);
|
|
return r;
|
|
}
|
|
|
|
|
|
char move(char *path1,char *path2)
|
|
{
|
|
char *tmp = get_full_path(path1);
|
|
path1 = malloc(4096);
|
|
strcpy(path1,tmp);
|
|
|
|
char *r=move_loop(path1,get_full_path(path2));
|
|
|
|
free(path1);
|
|
return r;
|
|
}
|
|
|
|
char write(char *path,void *data,dword size)
|
|
{
|
|
if(file_write(get_full_path(path),data,size))return 0;
|
|
return 1;
|
|
}
|
|
|
|
dword execute(char *path,char *arg)
|
|
{
|
|
return file_run(get_full_path(path),arg);
|
|
}
|
|
|
|
dword open(char *path)
|
|
{
|
|
return file_run("/sys/@open",get_full_path(path));
|
|
}
|
|
|
|
char rename(char *path,char *new_name)
|
|
{
|
|
if(!strcmp(path,new_name))return 0;
|
|
char *pos = path;
|
|
char *pos1 = &TMP1;
|
|
char *tmp = 0;
|
|
while(*pos)
|
|
{
|
|
*pos1=*pos;
|
|
if(*pos=='/')
|
|
{
|
|
if(*++pos)tmp = pos1;
|
|
}
|
|
else ++pos;
|
|
++pos1;
|
|
}
|
|
if(tmp)
|
|
{
|
|
while(*new_name)*++tmp = *new_name++;
|
|
*++tmp = 0;
|
|
return move(path,&TMP1);
|
|
}
|
|
return move(path,new_name);
|
|
}
|
|
|
|
char callback_copy(char *path1,char *path2,dword func)
|
|
{
|
|
pointer_callback_copy = func;
|
|
return copy(path1,path2);
|
|
}
|
|
|
|
char callback_move(char *path1,char *path2,dword func)
|
|
{
|
|
pointer_callback_move = func;
|
|
return move(path1,path2);
|
|
}
|
|
|
|
char callback_remove(char *path,dword func)
|
|
{
|
|
pointer_callback_remove = func;
|
|
return remove(path);
|
|
}
|
|
|
|
char *version = "Ver. 1.3, Author:Pavel Yakovlev, http://vk.com/pavelyakov39";
|
|
|
|
EXPORT_
|
|
export(execute)
|
|
export(open)
|
|
export(read)
|
|
export(write)
|
|
export(copy)
|
|
export(move)
|
|
export(remove)
|
|
export(rename)
|
|
export(get_size)
|
|
//export(set_attributes)
|
|
export(get_entries_count)
|
|
export(get_dir_info)
|
|
export(get_dir_position)
|
|
export(get_file_name)
|
|
|
|
export(get_full_path)
|
|
|
|
export(make_dir)
|
|
|
|
export(callback_copy)
|
|
export(callback_move)
|
|
export(callback_remove)
|
|
|
|
export(pointer_callback_copy)
|
|
export(pointer_callback_move)
|
|
export(pointer_callback_remove)
|
|
|
|
export(version)
|
|
_EXPORT |