Subversion Repositories Kolibri OS

Rev

Rev 7422 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #ifndef INCLUDE_FILESYSTEM_H
  2. #define INCLUDE_FILESYSTEM_H
  3. #print "[include <fs.h>]\n"
  4.  
  5. #ifndef INCLUDE_DATE_H
  6. #include "../lib/date.h"
  7. #endif
  8.  
  9. //===================================================//
  10. //                                                   //
  11. //              Basic System Functions               //
  12. //                                                   //
  13. //===================================================//
  14.  
  15. :struct f70{
  16.         dword   func;
  17.         dword   param1;
  18.         dword   param2;
  19.         dword   param3;
  20.         dword   param4;
  21.         char    rezerv;
  22.         dword   name;
  23. };
  24.  
  25. :struct BDVK {
  26.         dword   readonly:1, hidden:1, system:1, volume_label:1, isfolder:1, notarchived:1, :0;
  27.         byte    type_name;
  28.         byte    rez1, rez2, selected;
  29.         dword   timecreate;
  30.         date    datecreate;
  31.         dword   timelastaccess;
  32.         date    datelastaccess;
  33.         dword   timelastedit;
  34.         date    datelastedit;
  35.         dword   sizelo;
  36.         dword   sizehi;
  37.         char    name[518];
  38. };
  39.  
  40.  
  41.  
  42. :f70 getinfo_file_70;
  43. :dword GetFileInfo(dword file_path, bdvk_struct)
  44. {    
  45.     getinfo_file_70.func = 5;
  46.     getinfo_file_70.param1 =
  47.     getinfo_file_70.param2 =
  48.     getinfo_file_70.param3 = 0;
  49.     getinfo_file_70.param4 = bdvk_struct;
  50.     getinfo_file_70.rezerv = 0;
  51.     getinfo_file_70.name = file_path;
  52.     $mov eax,70
  53.     $mov ebx,#getinfo_file_70.func
  54.     $int 0x40
  55. }
  56.  
  57. :f70 setinfo_file_70;
  58. :dword SetFileInfo(dword file_path, bdvk_struct)
  59. {    
  60.     setinfo_file_70.func = 6;
  61.     setinfo_file_70.param1 =
  62.     setinfo_file_70.param2 =
  63.     setinfo_file_70.param3 = 0;
  64.     setinfo_file_70.param4 = bdvk_struct;
  65.     setinfo_file_70.rezerv = 0;
  66.     setinfo_file_70.name = file_path;
  67.     $mov eax,70
  68.     $mov ebx,#setinfo_file_70.func
  69.     $int 0x40
  70. }
  71.  
  72. :f70 run_file_70;
  73. :signed int RunProgram(dword run_path, run_param)
  74. {      
  75.     run_file_70.func = 7;
  76.     run_file_70.param1 =
  77.     run_file_70.param3 =
  78.     run_file_70.param4 =
  79.     run_file_70.rezerv = 0;
  80.     run_file_70.param2 = run_param;
  81.     run_file_70.name = run_path;
  82.     $mov eax,70
  83.     $mov ebx,#run_file_70.func
  84.     $int 0x40
  85. }
  86.  
  87. :f70 create_dir_70;
  88. :int CreateDir(dword new_folder_path)
  89. {
  90.         create_dir_70.func = 9;
  91.         create_dir_70.param1 =
  92.         create_dir_70.param2 =
  93.         create_dir_70.param3 =
  94.         create_dir_70.param4 =
  95.         create_dir_70.rezerv = 0;
  96.         create_dir_70.name = new_folder_path;
  97.         $mov eax,70
  98.         $mov ebx,#create_dir_70.func
  99.         $int 0x40
  100. }
  101.  
  102. :f70 del_file_70;      
  103. :int DeleteFile(dword del_file_path)
  104. {    
  105.         del_file_70.func = 8;
  106.         del_file_70.param1 =
  107.         del_file_70.param2 =
  108.         del_file_70.param3 =
  109.         del_file_70.param4 =
  110.         del_file_70.rezerv = 0;
  111.         del_file_70.name = del_file_path;
  112.         $mov eax,70
  113.         $mov ebx,#del_file_70.func
  114.         $int 0x40
  115. }
  116.  
  117. :f70 read_file_70;
  118. :int ReadFile(dword offset, data_size, buffer, file_path)
  119. {
  120.         read_file_70.func = 0;
  121.         read_file_70.param1 = offset;
  122.         read_file_70.param2 = 0;
  123.         read_file_70.param3 = data_size;
  124.         read_file_70.param4 = buffer;
  125.         read_file_70.rezerv = 0;
  126.         read_file_70.name = file_path;
  127.         $mov eax,70
  128.         $mov ebx,#read_file_70.func
  129.         $int 0x40
  130. }
  131.  
  132. :f70 write_file_70;
  133. :int CreateFile(dword data_size, buffer, file_path)
  134. {
  135.         write_file_70.func = 2;
  136.         write_file_70.param1 = 0;
  137.         write_file_70.param2 = 0;
  138.         write_file_70.param3 = data_size;
  139.         write_file_70.param4 = buffer;
  140.         write_file_70.rezerv = 0;
  141.         write_file_70.name = file_path;
  142.         $mov eax,70
  143.         $mov ebx,#write_file_70.func
  144.         $int 0x40
  145. }
  146.  
  147.   ////////////////////////////////////////
  148.  //     WriteInFileThatAlredyExists    //
  149. ////////////////////////////////////////
  150. :f70 write_file_offset_70;
  151. :int WriteFile(dword offset, data_size, buffer, file_path)
  152. {
  153.         write_file_offset_70.func = 3;
  154.         write_file_offset_70.param1 = offset;
  155.         write_file_offset_70.param2 = 0;
  156.         write_file_offset_70.param3 = data_size;
  157.         write_file_offset_70.param4 = buffer;
  158.         write_file_offset_70.rezerv = 0;
  159.         write_file_offset_70.name = file_path;
  160.         $mov eax,70
  161.         $mov ebx,#write_file_offset_70.func
  162.         $int 0x40
  163. }
  164.  
  165. :f70 read_dir_70;
  166. :int ReadDir(dword file_count, read_buffer, dir_path)
  167. {
  168.         read_dir_70.func = 1;
  169.         read_dir_70.param1 =
  170.         read_dir_70.param2 =
  171.         read_dir_70.rezerv = 0;
  172.         read_dir_70.param3 = file_count;
  173.         read_dir_70.param4 = read_buffer;
  174.         read_dir_70.name = dir_path;
  175.         $mov eax,70
  176.         $mov ebx,#read_dir_70.func
  177.         $int 0x40
  178. }
  179.  
  180. //ECX - buf pointer
  181. inline fastcall void SetCurDir( ECX)
  182. {
  183.         EAX=30;
  184.         EBX=1;
  185.         $int 0x40
  186. }
  187.  
  188. //ECX - buf pointer
  189. //EDX - buf size
  190. inline fastcall void GetCurDir( ECX, EDX)
  191. {
  192.         EAX=30;
  193.         EBX=2;
  194.         $int 0x40
  195. }
  196.  
  197. //===================================================//
  198. //                                                   //
  199. //                        Misc                       //
  200. //                                                   //
  201. //===================================================//
  202.  
  203. :bool dir_exists(dword fpath)
  204. {
  205.         char buf[32];
  206.         if (!ReadDir(0, #buf, fpath)) return true;
  207.         return false;
  208. }
  209.  
  210. /*
  211. // This implementation of dir_exists() is faster than
  212. // previous but here virtual folders like
  213. // '/' and '/tmp' are not recognised as FOLDERS
  214. // by GetFileInfo() => BDVK.isfolder attribute :(
  215.  
  216. :bool dir_exists(dword fpath)
  217. {
  218.         BDVK fpath_atr;
  219.         if (GetFileInfo(fpath, #fpath_atr) != 0) return false;
  220.         return fpath_atr.isfolder;
  221. }
  222. */
  223.  
  224. :bool file_exists(dword fpath)
  225. {
  226.         BDVK ReadFile_atr;
  227.         if (! GetFileInfo(fpath, #ReadFile_atr)) return true;
  228.         return false;
  229. }
  230.  
  231. enum
  232. {
  233.         DIRS_ALL,
  234.         DIRS_NOROOT,
  235.         DIRS_ONLYREAL
  236. };
  237. :int GetDir(dword dir_buf, file_count, path, doptions)
  238. {
  239.         dword buf, fcount, error;
  240.         buf = malloc(32);
  241.         error = ReadDir(0, buf, path);
  242.         if (!error)
  243.         {
  244.                 fcount = ESDWORD[buf+8];
  245.                 buf = realloc(buf, fcount+1*304+32);
  246.                 ReadDir(fcount, buf, path);
  247.                 //fcount=EBX;
  248.  
  249.                 if (doptions == DIRS_ONLYREAL)
  250.                 {
  251.                         if (!strcmp(".",buf+72)) {fcount--; memmov(buf,buf+304,fcount*304);}
  252.                         if (!strcmp("..",buf+72)) {fcount--; memmov(buf,buf+304,fcount*304);}
  253.                 }
  254.                 if (doptions == DIRS_NOROOT)
  255.                 {
  256.                         if (!strcmp(".",buf+72)) {fcount--; memmov(buf,buf+304,fcount*304);}
  257.                 }
  258.  
  259.                 ESDWORD[dir_buf] = buf;
  260.                 ESDWORD[file_count] = fcount;
  261.         }
  262.         else
  263.         {
  264.                 ESDWORD[dir_buf] = free(buf);
  265.                 ESDWORD[file_count] = 0;
  266.         }
  267.         return error;
  268. }
  269.  
  270. :dword abspath(dword relative_path) //GetAbsolutePathFromRelative()
  271. {
  272.         char absolute_path[4096];
  273.         if (ESBYTE[relative_path]=='/')
  274.         {
  275.                 strcpy(#absolute_path, relative_path);
  276.         }
  277.         else
  278.         {
  279.                 strcpy(#absolute_path, I_Path);
  280.                 absolute_path[strrchr(#absolute_path, '/')] = '\0';
  281.                 strcat(#absolute_path, relative_path);
  282.         }
  283.         return #absolute_path;
  284. }
  285.  
  286. :dword GetIni(dword ini_path, ini_name) //search it on /kolibrios/ then on /sys/
  287. {
  288.         strcpy(ini_path, "/kolibrios/settings/");
  289.         strcat(ini_path, ini_name);
  290.         if (!file_exists(ini_path)) {
  291.                 strcpy(ini_path, "/sys/SETTINGS/");
  292.                 strcat(ini_path, ini_name);
  293.         }
  294.         return ini_path;
  295. }
  296.  
  297. :dword notify(dword notify_param)
  298. {
  299.         return RunProgram("/sys/@notify", notify_param);
  300. }
  301.  
  302. :void die(dword _last_msg)
  303. {
  304.         notify(_last_msg);
  305.         ExitProcess();
  306. }
  307.  
  308. //===================================================//
  309. //                                                   //
  310. //                   Convert Size                    //
  311. //                                                   //
  312. //===================================================//
  313.  
  314. :byte ConvertSize_size_prefix[8];
  315. :dword ConvertSize(dword bytes)
  316. {
  317.   byte size_nm[4];
  318.   if (bytes>=1073741824) strlcpy(#size_nm, "Gb",2);
  319.   else if (bytes>=1048576) strlcpy(#size_nm, "Mb",2);
  320.   else if (bytes>=1024) strlcpy(#size_nm, "Kb",2);
  321.   else strlcpy(#size_nm, "b ",2);
  322.   while (bytes>1023) bytes >>= 10;
  323.   sprintf(#ConvertSize_size_prefix,"%d %s",bytes,#size_nm);
  324.   return #ConvertSize_size_prefix;
  325. }
  326.  
  327. :dword ConvertSize64(dword bytes_lo, bytes_hi)
  328. {
  329.   if (bytes_hi > 0) {
  330.         if (bytes_lo>=1073741824) bytes_lo >>= 30; else bytes_lo = 0;
  331.         sprintf(#ConvertSize_size_prefix,"%d Gb",bytes_hi<<2 + bytes_lo);
  332.         return #ConvertSize_size_prefix;
  333.   }
  334.   else return ConvertSize(bytes_lo);
  335. }
  336.  
  337. :unsigned char size[25];
  338. :dword ConvertSizeToKb(unsigned int bytes)
  339. {
  340.         unsigned int kb;
  341.         dword kb_line;
  342.  
  343.         if (bytes >= 1024)
  344.         {
  345.                 kb_line = itoa(bytes / 1024);
  346.                 strcpy(#size, kb_line);
  347.                 strcat(#size, " Kb");          
  348.         }
  349.         else {
  350.                 kb_line = itoa(bytes);
  351.                 strcpy(#size, kb_line);
  352.                 strcat(#size, " b");
  353.         }
  354.  
  355.         return #size;
  356. }
  357.  
  358. //===================================================//
  359. //                                                   //
  360. //                      Copy                         //
  361. //                                                   //
  362. //===================================================//
  363.  
  364. :int CopyFileAtOnce(dword size, copyFrom, copyTo)
  365. dword cbuf;
  366. int error;
  367. {
  368.         cbuf = malloc(size);
  369.         if (error = ReadFile(0, size, cbuf, copyFrom))
  370.         {
  371.                 debugln("Error: CopyFileAtOnce->ReadFile");
  372.         }
  373.         else
  374.         {
  375.                 if (error = CreateFile(size, cbuf, copyTo)) debugln("Error: CopyFileAtOnce->CreateFile");
  376.         }
  377.         free(cbuf);
  378.         return error;
  379. }
  380.  
  381. :int CopyFileByBlocks(dword size, copyFrom, copyTo)
  382. dword cbuf;
  383. int error=-1;
  384. dword offpos=0;
  385. int block_size=1024*1024*4; //copy by 4 MiB
  386. {
  387.         if (GetFreeRAM()>1024*78) {
  388.                 //Set block size 32 MiB
  389.                 block_size <<= 3;
  390.         }
  391.         cbuf = malloc(block_size);
  392.         if (error = CreateFile(0, 0, copyTo))
  393.         {
  394.                 debugln("Error: CopyFileByBlocks->CreateFile");
  395.                 size = -1;     
  396.         }
  397.         while(offpos < size)
  398.         {
  399.                 error = ReadFile(offpos, block_size, cbuf, copyFrom);
  400.                 if (error = 6) { //File ended before last byte was readed
  401.                         block_size = EBX;
  402.                         if (block_size+offpos>=size) error=0;
  403.                 }
  404.                 else
  405.                         if (error!=0) {
  406.                                 debugln("Error: CopyFileByBlocks->ReadFile");
  407.                                 break;
  408.                         }
  409.                 if (error = WriteFile(offpos, block_size, cbuf, copyTo)) {
  410.                         debugln("Error: CopyFileByBlocks->WriteFile");
  411.                         break;
  412.                 }
  413.                 offpos += block_size;
  414.         }
  415.         free(cbuf);
  416.         return error;
  417. }
  418.  
  419. //===================================================//
  420. //                                                   //
  421. //                  Directory Size                   //
  422. //                                                   //
  423. //===================================================//
  424.  
  425. :struct _dir_size
  426. {
  427.         BDVK dir_info;
  428.         dword folders;
  429.         dword files;
  430.         dword bytes;
  431.         void get();    
  432.         void calculate_loop(); 
  433. } dir_size;
  434.  
  435. :void _dir_size::get(dword way)
  436. {
  437.         folders = files = bytes = 0;
  438.         if (way) calculate_loop(way);
  439. }
  440.  
  441. :void _dir_size::calculate_loop(dword way)
  442. {
  443.         dword dirbuf, fcount, i, filename;
  444.         dword cur_file;
  445.         if (dir_exists(way))
  446.         {
  447.                 cur_file = malloc(4096);
  448.                 // In the process of recursive descent, memory must be allocated dynamically,
  449.                 // because the static memory -> was a bug !!! But unfortunately pass away to sacrifice speed.
  450.                 GetDir(#dirbuf, #fcount, way, DIRS_ONLYREAL);
  451.                 for (i=0; i<fcount; i++)
  452.                 {
  453.                         filename = i*304+dirbuf+72;
  454.                         sprintf(cur_file,"%s/%s",way,filename);
  455.                        
  456.                         if (TestBit(ESDWORD[filename-40], 4) )
  457.                         {
  458.                                 folders++;
  459.                                 calculate_loop(cur_file);
  460.                         }
  461.                         else
  462.                         {
  463.                                 GetFileInfo(cur_file, #dir_info);
  464.                                 bytes += dir_info.sizelo;
  465.                                 files++;
  466.                         }
  467.                 }
  468.                 free(cur_file);
  469.                 free(dirbuf);
  470.         }
  471. }
  472.  
  473. #endif