Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #ifndef FS_C_INCLUDE
  2. #define FS_C_INCLUDE
  3.  
  4. #include "stdlib.c"
  5.  
  6. #pragma pack(push,1)
  7. typedef struct
  8. {
  9. unsigned        p00;
  10. unsigned        p04;
  11. unsigned        p08;
  12. unsigned        p12;
  13. unsigned        p16;
  14. char            p20;
  15. char            *p21;
  16. } FS_struct70;
  17. #pragma pack(pop)
  18.  
  19. #pragma pack(push,1)
  20. typedef struct
  21. {
  22. unsigned        p00;
  23. char            p04;
  24. char            p05[3];
  25. unsigned        p08;
  26. unsigned        p12;
  27. unsigned        p16;
  28. unsigned        p20;
  29. unsigned        p24;
  30. unsigned        p28;
  31. //unsigned      p32[2];
  32. long long p32;
  33. unsigned        p40;
  34. } FS_struct_BDVK;
  35. #pragma pack(pop)
  36.  
  37. #define FS_COPY_BUFFER_SET 0x100000
  38. static inline char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
  39.  
  40. static inline char *string_error_code(char code)
  41. {
  42.         if(!code)return "Successfully!";
  43.         if(code==1)return "Not defined basis and / or hard disk partition (sub-functions 7, 8 function 21)!";
  44.         if(code==2)return "Function is not supported for this file system!";
  45.         if(code==3)return "Unknown file system!";
  46.         if(code==4)return "Reserved, never returned to the current implementation!";
  47.         if(code==5)return "File not found!";
  48.         if(code==6)return "The file is ended!";
  49.         if(code==7)return "Pointer out the application memory!";
  50.         if(code==8)return "Disk is full!";
  51.         if(code==9)return "FAT table is destroyed!";
  52.         if(code==10)return "Access is denied!";
  53.         if(code==11)return "Device error!";
  54.         return "An unexpected error!";
  55. }
  56.  
  57. static inline dword sprintf(char *mstr,const char *fmt,...)
  58. {
  59.        
  60.         dword *arg = &fmt;
  61.         char *tmp = 0;
  62.         char *pos = mstr;
  63.         --pos;
  64.         --fmt;
  65.         while(*++fmt)
  66.         {
  67.                 char s = *fmt;
  68.                 if(s=='%')
  69.                 {
  70.                         s = *++fmt;
  71.                         if(s=='s')
  72.                         {
  73.                                 tmp = *++arg;
  74.                                 while(*tmp)*++pos = *tmp++;
  75.                         }
  76.                         else
  77.                         {
  78.                                 *++pos='%';
  79.                                 --fmt;
  80.                         }
  81.                 }
  82.                 else *++pos=s;
  83.         }
  84.         *++pos = 0;
  85.         return pos-mstr;
  86. }
  87.  
  88. static inline int FS_file_70(FS_struct70 *k)
  89. {
  90.         asm volatile ("int $0x40"::"a"(70), "b"(k));
  91. }
  92.  
  93. FS_struct_BDVK ret_struct;
  94. static inline FS_struct_BDVK* get_bdvk(char *path)
  95. {
  96.         FS_struct70 file_read_struct;
  97.         file_read_struct.p00 = 5;
  98.         file_read_struct.p04 = 0;
  99.         file_read_struct.p08 = 0;
  100.         file_read_struct.p12 = 0;
  101.         file_read_struct.p16 = (unsigned)&ret_struct;
  102.         file_read_struct.p20 = 0;
  103.         file_read_struct.p21 = path;
  104.         FS_file_70(&file_read_struct);
  105.         return (FS_struct_BDVK*)&ret_struct;
  106. }
  107.  
  108. static inline long long file_size(char *path)
  109. {
  110.         FS_struct_BDVK *data =  get_bdvk(path);
  111.         return data->p32;
  112. }
  113.  
  114. static inline byte file_isdir(char *path)
  115. {
  116.         FS_struct_BDVK *data =  get_bdvk(path);
  117.         if(data->p00&0b10000)return 1;
  118.         return 0;
  119. }
  120.  
  121. static inline byte file_ismetka(char *path)
  122. {
  123.         FS_struct_BDVK *data =  get_bdvk(path);
  124.         if(data->p00&0b1000)return 1;
  125.         return 0;
  126. }
  127.  
  128. static inline byte file_isfile()
  129. {
  130.         //FS_struct_BDVK *data =  get_bdvk(path);
  131.         if(ret_struct.p00&0b11000)return 0;
  132.         return 1;
  133. }
  134.  
  135. static inline int file_run(char *path,char *arg)
  136. {
  137.         FS_struct70 file_read_struct;
  138.         file_read_struct.p00 = 7;
  139.         file_read_struct.p04 = 0;
  140.         file_read_struct.p08 = arg;
  141.         file_read_struct.p12 = 0;
  142.         file_read_struct.p16 = 0;
  143.         file_read_struct.p20 = 0;
  144.         file_read_struct.p21 = path;
  145.         return FS_file_70(&file_read_struct);
  146.        
  147. }
  148.  
  149. static inline int file_read_binary(char *path,unsigned pos,unsigned size,void *adr)
  150. {
  151.         FS_struct70 file_read_struct;
  152.         file_read_struct.p00 = 0;
  153.         file_read_struct.p04 = pos;
  154.         file_read_struct.p08 = 0;
  155.         file_read_struct.p12 = size;
  156.         file_read_struct.p16 = (unsigned)adr;
  157.         file_read_struct.p20 = 0;
  158.         file_read_struct.p21 = path;
  159.         char c = FS_file_70(&file_read_struct);
  160.         if(c)
  161.         {
  162.                 sprintf(&BUF_COPY,"'Error read file (%s) file: %s.'E",string_error_code(c),path);
  163.                 file_run("/sys/@notify",&BUF_COPY);
  164.         }
  165.         return c;
  166. }
  167.  
  168. static inline int file_delete(char *path)
  169. {
  170.         FS_struct70 file_read_struct;
  171.         file_read_struct.p00 = 8;
  172.         file_read_struct.p04 = 0;
  173.         file_read_struct.p08 = 0;
  174.         file_read_struct.p12 = 0;
  175.         file_read_struct.p16 = 0;
  176.         file_read_struct.p20 = 0;
  177.         file_read_struct.p21 = path;
  178.         char c = FS_file_70(&file_read_struct);
  179.         if(c)
  180.         {
  181.                 sprintf(&BUF_COPY,"'Error delete file: %s. Info: %s'E",string_error_code(c),path);
  182.                 file_run("/sys/@notify",&BUF_COPY);
  183.         }
  184.         return c;
  185. }
  186.  
  187. static inline int file_mkdir(char *path)
  188. {
  189.         FS_struct70 file_read_struct;
  190.         file_read_struct.p00 = 9;
  191.         file_read_struct.p04 = 0;
  192.         file_read_struct.p08 = 0;
  193.         file_read_struct.p12 = 0;
  194.         file_read_struct.p16 = 0;
  195.         file_read_struct.p20 = 0;
  196.         file_read_struct.p21 = path;
  197.         char c = FS_file_70(&file_read_struct);
  198.         if(c)
  199.         {
  200.                 sprintf(&BUF_COPY,"'Error make dir: %s. Info: %s.'E",string_error_code(c),path);
  201.                 file_run("/sys/@notify",&BUF_COPY);
  202.         }
  203.         return c;
  204. }
  205.  
  206. static inline int file_write(char *path,void *ukaz,dword size)
  207. {
  208.         FS_struct70 file_read_struct;
  209.         file_read_struct.p00 = 2;
  210.         file_read_struct.p04 = 0;
  211.         file_read_struct.p08 = 0;
  212.         file_read_struct.p12 = size;
  213.         file_read_struct.p16 = ukaz;
  214.         file_read_struct.p20 = 0;
  215.         file_read_struct.p21 = path;
  216.         char c = FS_file_70(&file_read_struct);
  217.         if(c)
  218.         {
  219.                 sprintf(&BUF_COPY,"'Error write file: %s. Info: %s.'E",string_error_code(c),path);
  220.                 file_run("/sys/@notify",&BUF_COPY);
  221.         }
  222.         return c;
  223. }
  224.  
  225. static inline int file_rewrite(char *path,dword pos1,dword pos2,void *ukaz,dword size)
  226. {
  227.         FS_struct70 file_read_struct;
  228.         file_read_struct.p00 = 3;
  229.         file_read_struct.p04 = pos1;
  230.         file_read_struct.p08 = pos2;
  231.         file_read_struct.p12 = size;
  232.         file_read_struct.p16 = ukaz;
  233.         file_read_struct.p20 = 0;
  234.         file_read_struct.p21 = path;
  235.         char c = FS_file_70(&file_read_struct);
  236.         if(c)
  237.         {
  238.                 sprintf(&BUF_COPY,"'Error rewrite file (%s) file: %s.'E",string_error_code(c),path);
  239.                 file_run("/sys/@notify",&BUF_COPY);
  240.         }
  241.         return c;
  242. }
  243.  
  244.  
  245. static inline char file_copy(char *path1,char *path2)
  246. {
  247.         long long size = file_size(path1);
  248.         if(!size)file_write(path2,&BUF_COPY,0);
  249.         long long cel = size;
  250.         cel /= FS_COPY_BUFFER_SET;
  251.         dword ost = size-cel*FS_COPY_BUFFER_SET;
  252.         long long i = 0;
  253.         char err=0;
  254.         if(cel)
  255.         {
  256.                 if(file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
  257.                 if(file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
  258.                 ++i;
  259.         }
  260.         else
  261.         {
  262.                 if(file_read_binary(path1,0,ost,&BUF_COPY))goto ERROR;
  263.                 if(file_write(path2,&BUF_COPY,ost))goto ERROR;
  264.                 return 1;
  265.         }
  266.         while(i<cel)
  267.         {
  268.                 if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY))goto ERROR;
  269.                 if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET))goto ERROR;
  270.                 ++i;
  271.         }
  272.         if(file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY))goto ERROR;
  273.         if(file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost))goto ERROR;
  274.         return 1;
  275.         ERROR:
  276.        
  277.         //asm("":"=a"(err));
  278.         //sprintf(&BUF_COPY,"Error %s file: %s.",string_error_code(err),path1);
  279.         //file_run("/sys/@notify",&BUF_COPY);
  280.         return 0;
  281. }
  282.  
  283. /*
  284. dword FS_COPY_BUFFER_SET_POINT = 0x100000;
  285. dword BUF_COPY_POINT = 0;
  286. static inline char file_copy(char *path1,char *path2)
  287. {
  288.         long long size = file_size(path1);
  289.         if(!size)file_write(path2,BUF_COPY_POINT,0);
  290.         long long cel = size;
  291.         cel /= FS_COPY_BUFFER_SET_POINT;
  292.         dword ost = size-cel*FS_COPY_BUFFER_SET_POINT;
  293.         long long i = 0;
  294.         char err=0;
  295.         if(cel)
  296.         {
  297.                 if(file_read_binary(path1,0,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
  298.                 if(file_write(path2,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
  299.                 ++i;
  300.         }
  301.         else
  302.         {
  303.                 if(file_read_binary(path1,0,ost,BUF_COPY_POINT))goto ERROR;
  304.                 if(file_write(path2,BUF_COPY_POINT,ost))goto ERROR;
  305.                 return 1;
  306.         }
  307.         while(i<cel)
  308.         {
  309.                 if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,FS_COPY_BUFFER_SET_POINT,BUF_COPY_POINT))goto ERROR;
  310.                 if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,FS_COPY_BUFFER_SET_POINT))goto ERROR;
  311.                 ++i;
  312.         }
  313.         if(file_read_binary(path1,FS_COPY_BUFFER_SET_POINT*i,ost,BUF_COPY_POINT))goto ERROR;
  314.         if(file_rewrite(path2,FS_COPY_BUFFER_SET_POINT*i,0,BUF_COPY_POINT,ost))goto ERROR;
  315.         return 1;
  316.         ERROR:
  317.        
  318.         //asm("":"=a"(err));
  319.         //sprintf(BUF_COPY_POINT,"Error %s file: %s.",string_error_code(err),path1);
  320.         //file_run("/sys/@notify",BUF_COPY_POINT);
  321.         return 0;
  322. }
  323. */
  324. /*
  325. #define FS_COPY_BUFFER_SET 0x100000
  326. char BUF_COPY[FS_COPY_BUFFER_SET] = {0};
  327. static inline char file_copy(char *path1,char *path2)
  328. {
  329.         long long size = file_size(path1);
  330.         if(!size)file_write(path2,&BUF_COPY,0);
  331.         long long cel = size;
  332.         cel /= FS_COPY_BUFFER_SET;
  333.         dword ost = size-cel*FS_COPY_BUFFER_SET;
  334.         long long i = 0;
  335.        
  336.         if(cel)
  337.         {
  338.                 file_read_binary(path1,0,FS_COPY_BUFFER_SET,&BUF_COPY);
  339.                 file_write(path2,&BUF_COPY,FS_COPY_BUFFER_SET);
  340.                 ++i;
  341.         }
  342.         else
  343.         {
  344.                 file_read_binary(path1,0,ost,&BUF_COPY);
  345.                 file_write(path2,&BUF_COPY,ost);
  346.                 return 1;
  347.         }
  348.         while(i<cel)
  349.         {
  350.                 file_read_binary(path1,FS_COPY_BUFFER_SET*i,FS_COPY_BUFFER_SET,&BUF_COPY);
  351.                 file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,FS_COPY_BUFFER_SET);
  352.                 ++i;
  353.         }
  354.         file_read_binary(path1,FS_COPY_BUFFER_SET*i,ost,&BUF_COPY);
  355.         file_rewrite(path2,FS_COPY_BUFFER_SET*i,0,&BUF_COPY,ost);
  356.         return 1;
  357. }
  358. */
  359. long long size_long_file=0;
  360.  
  361. static inline void *file_read(char *path)
  362. {
  363.         size_long_file = file_size(path);
  364.         void *data = malloc(size_long_file+1);
  365.        
  366.         if(file_read_binary(path,0,size_long_file,data))return 0;
  367.        
  368.         return data;
  369. }
  370.  
  371. static inline void *file_readKPACK(char *path)
  372. {
  373.         void *data = 0;
  374.         dword size=0;
  375.         asm ("int $0x40":"=a"(data),"=d"(size):"a"(68), "b"(27), "c"(path));
  376.         size_long_file = size;
  377.         asm volatile(""::"c"(size));
  378.         return data;
  379. }
  380.  
  381. static inline int file_read_dir(dword begin,dword file_count,dword read_buffer,char *dir_path)
  382. {
  383.         FS_struct70 file_read_struct;
  384.         file_read_struct.p00 = 1;
  385.         file_read_struct.p04 = begin;
  386.         file_read_struct.p08 = 0;
  387.         file_read_struct.p12 = file_count;
  388.         file_read_struct.p16 = read_buffer;
  389.         file_read_struct.p20 = 0;
  390.         file_read_struct.p21 = dir_path;
  391.         return FS_file_70(&file_read_struct);
  392. }
  393.  
  394. #endif