/*

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