kolibrios/programs/develop/libraries/libs_v2/fs.c

897 lines
20 KiB
C
Raw Normal View History

/*
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