API tools faq
paste
BigETI

main.cpp - b_io

BigETI
Apr 29th, 2013
246
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.88 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.     Binary files I/O plugin made by BigETI © 2013
  3. */
  4.  
  5. #include <string>
  6. #include <algorithm>
  7. #include <vector>
  8. #include <ctime>
  9. #include "SDK\amx\amx.h"
  10. #include "SDK\plugincommon.h"
  11.  
  12. #define vector_foreach(type,vect,var)   for(vector<type>::iterator (var)=(vect).begin();(var)!=(vect).end();++(var))
  13.  
  14. typedef void (*logprintf_t)(char* format, ...);
  15. logprintf_t logprintf;
  16. extern void *pAMXFunctions;
  17.  
  18. using namespace std;
  19.  
  20. struct B_IO_AMX_STRUCT
  21. {
  22.     AMX *amx_ptr;
  23.     FILE *current_file_handle;
  24. };
  25.  
  26. typedef vector<B_IO_AMX_STRUCT> B_IO_AMX_STRUCT_VECTOR;
  27.  
  28. enum B_IO_MODE_ENUM
  29. {
  30.     B_IO_MODE_READ,
  31.     B_IO_MODE_WRITE,
  32.     B_IO_MODE_APPEND,
  33.     B_IO_MODE_NEW,
  34.     B_IO_MODE_ADD,
  35.     B_IO_MODE_UPDATE
  36. };
  37.  
  38. B_IO_AMX_STRUCT_VECTOR b_io_amx_vect;
  39.  
  40. FILE *amx_fopen(AMX *amx, cell *file_name, B_IO_MODE_ENUM mode)
  41. {
  42.     int str_len;
  43.     cell *addr = NULL;
  44.     amx_GetAddr(amx, *file_name, &addr);
  45.     amx_StrLen(addr, &str_len);
  46.     if(str_len)
  47.     {
  48.         char *var_c_str = new char[++str_len];
  49.         if(var_c_str == NULL)
  50.         {
  51.             logprintf("[BIO ERROR] Out of memory!");
  52.             exit(0);
  53.         }
  54.         amx_GetString(var_c_str, addr, 0, str_len);
  55.         char *t_c_str = var_c_str;
  56.         while(*t_c_str != '\0')
  57.         {
  58.             switch(*t_c_str)
  59.             {
  60.                 case '\\': case ':': case '*': case '?': case '\"': case '<': case '>': case '|':
  61.                     logprintf("[BIO ERROR] Attempted to open file \"%s\"", var_c_str);
  62.                     return NULL;
  63.                 case '.':
  64.                     t_c_str++;
  65.                     if(*t_c_str == '.')
  66.                     {
  67.                         logprintf("[BIO ERROR] Attempted to open file \"%s\"", var_c_str);
  68.                         return NULL;
  69.                     }
  70.                     break;
  71.             }
  72.             t_c_str++;
  73.         }
  74.         char *final_file_name = new char[str_len += 12];
  75.         if(final_file_name == NULL)
  76.         {
  77.             delete[] var_c_str;
  78.             logprintf("[BIO ERROR] Out of memory!");
  79.             exit(0);
  80.         }
  81.         strcpy_s(final_file_name, str_len, "scriptfiles/");
  82.         strcat_s(final_file_name, str_len, var_c_str);
  83.         FILE *ret;
  84.         switch(mode)
  85.         {
  86.             case B_IO_MODE_READ:
  87.                 fopen_s(&ret, final_file_name, "rb");
  88.                 break;
  89.             case B_IO_MODE_WRITE:
  90.                 fopen_s(&ret, final_file_name, "wb");
  91.                 break;
  92.             case B_IO_MODE_APPEND:
  93.                 fopen_s(&ret, final_file_name, "ab");
  94.                 break;
  95.             case B_IO_MODE_NEW:
  96.                 fopen_s(&ret, final_file_name, "wb+");
  97.                 break;
  98.             case B_IO_MODE_ADD:
  99.                 fopen_s(&ret, final_file_name, "ab+");
  100.                 break;
  101.             case B_IO_MODE_UPDATE:
  102.                 fopen_s(&ret, final_file_name, "rb+");
  103.                 break;
  104.             default:
  105.                 logprintf("[BIO ERROR] Attempted to set file stream mode to ID:%d for \"%s\"", mode, var_c_str);
  106.                 delete[] var_c_str;
  107.                 delete[] final_file_name;
  108.                 return NULL;
  109.         }
  110.         delete[] var_c_str;
  111.         delete[] final_file_name;
  112.         return ret;
  113.     }
  114.     logprintf("[BIO ERROR] Null string detected!");
  115.     return NULL;
  116. }
  117.  
  118. // native BFile:BIO_open(const file_name[], b_io_mode:mode = b_io_mode_update);
  119. cell AMX_NATIVE_CALL AMX_BIO_open(AMX *amx, cell *params)
  120. {
  121.     return (cell)amx_fopen(amx, &params[1], (B_IO_MODE_ENUM)params[2]);
  122. }
  123.  
  124. // native BFile:BIO_temp();
  125. cell AMX_NATIVE_CALL AMX_BIO_temp(AMX *amx, cell *params)
  126. {
  127.     FILE *ret;
  128.     tmpfile_s(&ret);
  129.     return (cell)ret;
  130. }
  131.  
  132. // native BIO_close(BFile:file_handle);
  133. cell AMX_NATIVE_CALL AMX_BIO_close(AMX *amx, cell *params)
  134. {
  135.     return (cell)fclose((FILE *)params[1]);
  136. }
  137.  
  138. // native BIO_read_8(BFile:file_handle, position = 0, seek_whence:whence = seek_current);
  139. cell AMX_NATIVE_CALL AMX_BIO_read_8(AMX *amx, cell *params)
  140. {
  141.     fseek((FILE *)params[1], (long)params[2], (int)params[3]);
  142.     return (cell)fgetc((FILE *)params[1]);
  143. }
  144.  
  145. // native BIO_read_16(BFile:file_handle, position = 0, seek_whence:whence = seek_current);
  146. cell AMX_NATIVE_CALL AMX_BIO_read_16(AMX *amx, cell *params)
  147. {
  148.     fseek((FILE *)params[1], (long)params[2], (int)params[3]);
  149.     cell ret = NULL;
  150.     fread(&ret, 2, 1, (FILE *)params[1]);
  151.     return ret;
  152. }
  153.  
  154. // native BIO_read_24(BFile:file_handle, position = 0, seek_whence:whence = seek_current);
  155. cell AMX_NATIVE_CALL AMX_BIO_read_24(AMX *amx, cell *params)
  156. {
  157.     fseek((FILE *)params[1], (long)params[2], (int)params[3]);
  158.     cell ret = NULL;
  159.     fread(&ret, 3, 1, (FILE *)params[1]);
  160.     return ret;
  161. }
  162.  
  163. // native BIO_read_32(BFile:file_handle, position = 0, seek_whence:whence = seek_current);
  164. cell AMX_NATIVE_CALL AMX_BIO_read_32(AMX *amx, cell *params)
  165. {
  166.     fseek((FILE *)params[1], (long)params[2], (int)params[3]);
  167.     cell ret = NULL;
  168.     fread(&ret, 4, 1, (FILE *)params[1]);
  169.     return ret;
  170. }
  171.  
  172. // native BIO_write_8(BFile:file_handle, value, position = 0, seek_whence:whence = seek_current);
  173. cell AMX_NATIVE_CALL AMX_BIO_write_8(AMX *amx, cell *params)
  174. {
  175.     fseek((FILE *)params[1], (long)params[3], (int)params[4]);
  176.     return (cell)fputc((int)(params[2]&0xFF), (FILE *)params[1]);
  177. }
  178.  
  179. // native BIO_write_16(BFile:file_handle, value, position = 0, seek_whence:whence = seek_current);
  180. cell AMX_NATIVE_CALL AMX_BIO_write_16(AMX *amx, cell *params)
  181. {
  182.     fseek((FILE *)params[1], (long)params[3], (int)params[4]);
  183.     return (cell)fwrite(&params[2], 2, 1, (FILE *)params[1]);
  184. }
  185.  
  186. // native BIO_write_24(BFile:file_handle, value, position = 0, seek_whence:whence = seek_current);
  187. cell AMX_NATIVE_CALL AMX_BIO_write_24(AMX *amx, cell *params)
  188. {
  189.     fseek((FILE *)params[1], (long)params[3], (int)params[4]);
  190.     return (cell)fwrite(&params[2], 3, 1, (FILE *)params[1]);
  191. }
  192.  
  193. // native BIO_write_32(BFile:file_handle, value, position = 0, seek_whence:whence = seek_current);
  194. cell AMX_NATIVE_CALL AMX_BIO_write_32(AMX *amx, cell *params)
  195. {
  196.     fseek((FILE *)params[1], (long)params[3], (int)params[4]);
  197.     return (cell)fwrite(&params[2], 4, 1, (FILE *)params[1]);
  198. }
  199.  
  200. // native BIO_read_8_arr(BFile:file_handle, bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  201. cell AMX_NATIVE_CALL AMX_BIO_read_8_arr(AMX *amx, cell *params)
  202. {
  203.     if(params[3] <= 0) return 0;
  204.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  205.     cell *addr, count_write = 0;
  206.     amx_GetAddr(amx, params[2], &addr);
  207.     for(int i = 0; i < params[3]; i++) if((addr[i] = fgetc((FILE *)params[1])) != EOF) count_write++;
  208.     return count_write;
  209. }
  210.  
  211. // native BIO_read_16_arr(BFile:file_handle, bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  212. cell AMX_NATIVE_CALL AMX_BIO_read_16_arr(AMX *amx, cell *params)
  213. {
  214.     if(params[3] <= 0) return 0;
  215.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  216.     cell *addr, count_write = 0;
  217.     amx_GetAddr(amx, params[2], &addr);
  218.     for(int i = 0; i < params[3]; i++) count_write += fread(&addr[i], 2, 1, (FILE *)params[1]);
  219.     return count_write;
  220. }
  221.  
  222. // native BIO_read_24_arr(BFile:file_handle, bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  223. cell AMX_NATIVE_CALL AMX_BIO_read_24_arr(AMX *amx, cell *params)
  224. {
  225.     if(params[3] <= 0) return 0;
  226.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  227.     cell *addr, count_write = 0;
  228.     amx_GetAddr(amx, params[2], &addr);
  229.     for(int i = 0; i < params[3]; i++) count_write += fread(&addr[i], 3, 1, (FILE *)params[1]);
  230.     return count_write;
  231. }
  232.  
  233. // native BIO_read_32_arr(BFile:file_handle, bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  234. cell AMX_NATIVE_CALL AMX_BIO_read_32_arr(AMX *amx, cell *params)
  235. {
  236.     if(params[3] <= 0) return 0;
  237.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  238.     cell *addr;
  239.     amx_GetAddr(amx, params[2], &addr);
  240.     return fread(addr, 4, params[3], (FILE *)params[1]);
  241. }
  242.  
  243. // native BIO_write_8_arr(BFile:file_handle, const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:seek_current);
  244. cell AMX_NATIVE_CALL AMX_BIO_write_8_arr(AMX *amx, cell *params)
  245. {
  246.     if(params[3] <= 0) return 0;
  247.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  248.     cell *addr, count_write = 0;
  249.     amx_GetAddr(amx, params[2], &addr);
  250.     for(int i = 0; i < params[3]; i++) count_write += fputc(addr[i], (FILE *)params[1]);
  251.     return count_write;
  252. }
  253.  
  254. // native BIO_write_16_arr(BFile:file_handle, const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  255. cell AMX_NATIVE_CALL AMX_BIO_write_16_arr(AMX *amx, cell *params)
  256. {
  257.     if(params[3] <= 0) return 0;
  258.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  259.     cell *addr, count_write = 0;
  260.     amx_GetAddr(amx, params[2], &addr);
  261.     for(int i = 0; i < params[3]; i++) count_write += fwrite(&addr[i], 2, 1, (FILE *)params[1]);
  262.     return count_write;
  263. }
  264.  
  265. // native BIO_write_24_arr(BFile:file_handle, const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  266. cell AMX_NATIVE_CALL AMX_BIO_write_24_arr(AMX *amx, cell *params)
  267. {
  268.     if(params[3] <= 0) return 0;
  269.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  270.     cell *addr, count_write = 0;
  271.     amx_GetAddr(amx, params[2], &addr);
  272.     for(int i = 0; i < params[3]; i++) count_write += fwrite(&addr[i], 3, 1, (FILE *)params[1]);
  273.     return count_write;
  274. }
  275.  
  276. // native BIO_write_32_arr(BFile:file_handle, const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  277. cell AMX_NATIVE_CALL AMX_BIO_write_32_arr(AMX *amx, cell *params)
  278. {
  279.     if(params[3] <= 0) return 0;
  280.     fseek((FILE *)params[1], (long)params[4], (int)params[5]);
  281.     cell *addr;
  282.     amx_GetAddr(amx, params[2], &addr);
  283.     return fwrite(addr, 4, params[3], (FILE *)params[1]);
  284. }
  285.  
  286. // native bool:BIO_eof(BFile:file_handle);
  287. cell AMX_NATIVE_CALL AMX_BIO_eof(AMX *amx, cell *params)
  288. {
  289.     return (cell)feof((FILE *)params[1]);
  290. }
  291.  
  292. // native bool:BIO_INST_open(const file_name[], b_io_mode:mode = b_io_mode_update);
  293. cell AMX_NATIVE_CALL AMX_BIO_INST_open(AMX *amx, cell *params)
  294. {
  295.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  296.     {
  297.         if(amx_it->amx_ptr != amx) continue;
  298.         if(amx_it->current_file_handle) fclose(amx_it->current_file_handle);
  299.         return (amx_it->current_file_handle = amx_fopen(amx, &params[1], (B_IO_MODE_ENUM)params[2])) != NULL;
  300.     }
  301.     return 0;
  302. }
  303.  
  304. // native bool:BIO_INST_temp();
  305. cell AMX_NATIVE_CALL AMX_BIO_INST_temp(AMX *amx, cell *params)
  306. {
  307.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  308.     {
  309.         if(amx_it->amx_ptr != amx) continue;
  310.         if(amx_it->current_file_handle) fclose(amx_it->current_file_handle);
  311.         tmpfile_s(&(amx_it->current_file_handle));
  312.         return (amx_it->current_file_handle != NULL);
  313.     }
  314.     return 0;
  315. }
  316.  
  317. // native bool:BIO_INST_close();
  318. cell AMX_NATIVE_CALL AMX_INST_close(AMX *amx, cell *params)
  319. {
  320.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  321.     {
  322.         if(amx_it->amx_ptr != amx) continue;
  323.         if(!amx_it->current_file_handle) return 0;
  324.         fclose(amx_it->current_file_handle);
  325.         amx_it->current_file_handle = NULL;
  326.         return 1;
  327.     }
  328.     return 0;
  329. }
  330.  
  331. // native BIO_INST_read_8(position = 0, seek_whence:whence = seek_current);
  332. cell AMX_NATIVE_CALL AMX_BIO_INST_read_8(AMX *amx, cell *params)
  333. {
  334.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  335.     {
  336.         if(amx_it->amx_ptr != amx) continue;
  337.         if(amx_it->current_file_handle == NULL)
  338.         {
  339.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  340.             return 0;
  341.         }
  342.         fseek(amx_it->current_file_handle, (long)params[1], (int)params[2]);
  343.         return fgetc(amx_it->current_file_handle);
  344.     }
  345.     return 0;
  346. }
  347.  
  348. // native BIO_INST_read_16(position = 0, seek_whence:whence = seek_current);
  349. cell AMX_NATIVE_CALL AMX_BIO_INST_read_16(AMX *amx, cell *params)
  350. {
  351.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  352.     {
  353.         if(amx_it->amx_ptr != amx) continue;
  354.         if(amx_it->current_file_handle == NULL)
  355.         {
  356.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  357.             return 0;
  358.         }
  359.         fseek(amx_it->current_file_handle, (long)params[1], (int)params[2]);
  360.         cell ret = NULL;
  361.         fread(&ret, 2, 1, amx_it->current_file_handle);
  362.         return ret;
  363.     }
  364.     return 0;
  365. }
  366.  
  367. // native BIO_INST_read_24(position = 0, seek_whence:whence = seek_current);
  368. cell AMX_NATIVE_CALL AMX_BIO_INST_read_24(AMX *amx, cell *params)
  369. {
  370.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  371.     {
  372.         if(amx_it->amx_ptr != amx) continue;
  373.         if(amx_it->current_file_handle == NULL)
  374.         {
  375.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  376.             return 0;
  377.         }
  378.         fseek(amx_it->current_file_handle, (long)params[1], (int)params[2]);
  379.         cell ret = NULL;
  380.         fread(&ret, 3, 1, amx_it->current_file_handle);
  381.         return ret;
  382.     }
  383.     return 0;
  384. }
  385.  
  386. // native BIO_INST_read_32(position = 0, seek_whence:whence = seek_current);
  387. cell AMX_NATIVE_CALL AMX_BIO_INST_read_32(AMX *amx, cell *params)
  388. {
  389.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  390.     {
  391.         if(amx_it->amx_ptr != amx) continue;
  392.         if(amx_it->current_file_handle == NULL)
  393.         {
  394.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  395.             return 0;
  396.         }
  397.         fseek(amx_it->current_file_handle, (long)params[1], (int)params[2]);
  398.         cell ret = NULL;
  399.         fread(&ret, 4, 1, amx_it->current_file_handle);
  400.         return ret;
  401.     }
  402.     return 0;
  403. }
  404.  
  405. // native BIO_INST_write_8(value, position = 0, seek_whence:whence = seek_current);
  406. cell AMX_NATIVE_CALL AMX_BIO_INST_write_8(AMX *amx, cell *params)
  407. {
  408.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  409.     {
  410.         if(amx_it->amx_ptr != amx) continue;
  411.         if(amx_it->current_file_handle == NULL)
  412.         {
  413.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  414.             return 0;
  415.         }
  416.         fseek(amx_it->current_file_handle, (long)params[2], (int)params[3]);
  417.         return fputc((int)(params[1]&0xFF), amx_it->current_file_handle);
  418.     }
  419.     return 0;
  420. }
  421.  
  422. // native BIO_INST_write_16(value, position = 0, seek_whence:whence = seek_current);
  423. cell AMX_NATIVE_CALL AMX_BIO_INST_write_16(AMX *amx, cell *params)
  424. {
  425.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  426.     {
  427.         if(amx_it->amx_ptr != amx) continue;
  428.         if(amx_it->current_file_handle == NULL)
  429.         {
  430.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  431.             return 0;
  432.         }
  433.         fseek(amx_it->current_file_handle, (long)params[2], (int)params[3]);
  434.         return fwrite(&params[1], 2, 1, amx_it->current_file_handle);
  435.     }
  436.     return 0;
  437. }
  438.  
  439. // native BIO_INST_write_24(value, position = 0, seek_whence:whence = seek_current);
  440. cell AMX_NATIVE_CALL AMX_BIO_INST_write_24(AMX *amx, cell *params)
  441. {
  442.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  443.     {
  444.         if(amx_it->amx_ptr != amx) continue;
  445.         if(amx_it->current_file_handle == NULL)
  446.         {
  447.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  448.             return 0;
  449.         }
  450.         fseek(amx_it->current_file_handle, (long)params[2], (int)params[3]);
  451.         return fwrite(&params[1], 3, 1, amx_it->current_file_handle);
  452.     }
  453.     return 0;
  454. }
  455.  
  456. // native BIO_INST_write_32(value, position = 0, seek_whence:whence = seek_current);
  457. cell AMX_NATIVE_CALL AMX_BIO_INST_write_32(AMX *amx, cell *params)
  458. {
  459.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  460.     {
  461.         if(amx_it->amx_ptr != amx) continue;
  462.         if(amx_it->current_file_handle == NULL)
  463.         {
  464.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  465.             return 0;
  466.         }
  467.         fseek(amx_it->current_file_handle, (long)params[2], (int)params[3]);
  468.         return fwrite(&params[1], 4, 1, amx_it->current_file_handle);
  469.     }
  470.     return 0;
  471. }
  472.  
  473. // native BIO_INST_read_8_arr(bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  474. cell AMX_NATIVE_CALL AMX_BIO_INST_read_8_arr(AMX *amx, cell *params)
  475. {
  476.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  477.     {
  478.         if(amx_it->amx_ptr != amx) continue;
  479.         if(amx_it->current_file_handle == NULL)
  480.         {
  481.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  482.             return 0;
  483.         }
  484.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  485.         cell *addr;
  486.         amx_GetAddr(amx, params[1], (cell **)&addr);
  487.         for(int i = 0; i < params[2]; i++) addr[i] = fgetc(amx_it->current_file_handle);
  488.         return 1;
  489.     }
  490.     return 0;
  491. }
  492.  
  493. // native BIO_INST_read_16_arr(bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  494. cell AMX_NATIVE_CALL AMX_BIO_INST_read_16_arr(AMX *amx, cell *params)
  495. {
  496.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  497.     {
  498.         if(amx_it->amx_ptr != amx) continue;
  499.         if(amx_it->current_file_handle == NULL)
  500.         {
  501.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  502.             return 0;
  503.         }
  504.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  505.         cell *addr;
  506.         amx_GetAddr(amx, params[1], &addr);
  507.         for(int i = 0; i < params[2]; i++) fread(addr+i, 2, 1, amx_it->current_file_handle);
  508.         return 1;
  509.     }
  510.     return 0;
  511. }
  512.  
  513. // native BIO_INST_read_24_arr(bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  514. cell AMX_NATIVE_CALL AMX_BIO_INST_read_24_arr(AMX *amx, cell *params)
  515. {
  516.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  517.     {
  518.         if(amx_it->amx_ptr != amx) continue;
  519.         if(amx_it->current_file_handle == NULL)
  520.         {
  521.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  522.             return 0;
  523.         }
  524.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  525.         cell *addr;
  526.         amx_GetAddr(amx, params[1], &addr);
  527.         for(int i = 0; i < params[2]; i++) fread(addr+i, 3, 1, amx_it->current_file_handle);
  528.         return 1;
  529.     }
  530.     return 0;
  531. }
  532.  
  533. // native BIO_INST_read_32_arr(bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  534. cell AMX_NATIVE_CALL AMX_BIO_INST_read_32_arr(AMX *amx, cell *params)
  535. {
  536.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  537.     {
  538.         if(amx_it->amx_ptr != amx) continue;
  539.         if(amx_it->current_file_handle == NULL)
  540.         {
  541.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  542.             return 0;
  543.         }
  544.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  545.         cell *addr;
  546.         amx_GetAddr(amx, params[1], &addr);
  547.         fread(addr, 4, params[2], amx_it->current_file_handle);
  548.         return 1;
  549.     }
  550.     return 0;
  551. }
  552.  
  553. // native BIO_INST_write_8_arr(const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  554. cell AMX_NATIVE_CALL AMX_BIO_INST_write_8_arr(AMX *amx, cell *params)
  555. {
  556.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  557.     {
  558.         if(amx_it->amx_ptr != amx) continue;
  559.         if(amx_it->current_file_handle == NULL)
  560.         {
  561.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  562.             return 0;
  563.         }
  564.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  565.         cell *addr, count_write = 0;
  566.         amx_GetAddr(amx, params[1], &addr);
  567.         for(int i = 0; i < params[2]; i++) count_write += fputc(addr[i], amx_it->current_file_handle);
  568.         return count_write;
  569.     }
  570.     return 0;
  571. }
  572.  
  573. // native BIO_INST_write_16_arr(const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  574. cell AMX_NATIVE_CALL AMX_BIO_INST_write_16_arr(AMX *amx, cell *params)
  575. {
  576.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  577.     {
  578.         if(amx_it->amx_ptr != amx) continue;
  579.         if(amx_it->current_file_handle == NULL)
  580.         {
  581.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  582.             return 0;
  583.         }
  584.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  585.         cell *addr, count_write = 0;
  586.         amx_GetAddr(amx, params[1], &addr);
  587.         for(int i = 0; i < params[2]; i++) count_write += fwrite(addr+i, 2, 1, amx_it->current_file_handle);
  588.         return count_write;
  589.     }
  590.     return 0;
  591. }
  592.  
  593. // native BIO_INST_write_24_arr(const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  594. cell AMX_NATIVE_CALL AMX_BIO_INST_write_24_arr(AMX *amx, cell *params)
  595. {
  596.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  597.     {
  598.         if(amx_it->amx_ptr != amx) continue;
  599.         if(amx_it->current_file_handle == NULL)
  600.         {
  601.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  602.             return 0;
  603.         }
  604.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  605.         cell *addr, count_write = 0;
  606.         amx_GetAddr(amx, params[1], &addr);
  607.         for(int i = 0; i < params[2]; i++) count_write += fwrite(addr+i, 3, 1, amx_it->current_file_handle);
  608.         return count_write;
  609.     }
  610.     return 0;
  611. }
  612.  
  613. // native BIO_INST_write_32_arr(const bin_array[], bin_array_len = sizeof bin_array, position = 0, seek_whence:whence = seek_current);
  614. cell AMX_NATIVE_CALL AMX_BIO_INST_write_32_arr(AMX *amx, cell *params)
  615. {
  616.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  617.     {
  618.         if(amx_it->amx_ptr != amx) continue;
  619.         if(amx_it->current_file_handle == NULL)
  620.         {
  621.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  622.             return 0;
  623.         }
  624.         fseek(amx_it->current_file_handle, (long)params[3], (int)params[4]);
  625.         cell *addr;
  626.         amx_GetAddr(amx, params[1], &addr);
  627.         return fwrite(addr, 4, params[2], amx_it->current_file_handle);
  628.     }
  629.     return 0;
  630. }
  631.  
  632. // native bool:BIO_INST_eof();
  633. cell AMX_NATIVE_CALL AMX_BIO_INST_eof(AMX *amx, cell *params)
  634. {
  635.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  636.     {
  637.         if(amx_it->amx_ptr != amx) continue;
  638.         if(amx_it->current_file_handle == NULL)
  639.         {
  640.             logprintf("[BIO WARNING] Not initialized instant file handle!");
  641.             return 0;
  642.         }
  643.         return (cell)feof(amx_it->current_file_handle);
  644.     }
  645.     return 0;
  646. }
  647.  
  648. PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports()
  649. {
  650.     return SUPPORTS_VERSION|SUPPORTS_AMX_NATIVES|SUPPORTS_PROCESS_TICK;
  651. }
  652.  
  653. PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData)
  654. {
  655.     pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
  656.     logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
  657.     logprintf("===========================");
  658.     logprintf("= Binary files I/O plugin =");
  659.     logprintf("=          Made by BigETI =");
  660.     logprintf("= Loaded!                 =");
  661.     logprintf("===========================");
  662.     return true;
  663. }
  664.  
  665. PLUGIN_EXPORT void PLUGIN_CALL Unload()
  666. {
  667.     logprintf("===========================");
  668.     logprintf("= Binary files I/O plugin =");
  669.     logprintf("=          Made by BigETI =");
  670.     logprintf("= Unloaded!               =");
  671.     logprintf("===========================");
  672. }
  673.  
  674. AMX_NATIVE_INFO PluginNatives[] =
  675. {
  676.     {"BIO_open", AMX_BIO_open},
  677.     {"BIO_temp", AMX_BIO_temp},
  678.     {"BIO_close", AMX_BIO_close},
  679.     {"BIO_read_8", AMX_BIO_read_8},
  680.     {"BIO_read_16", AMX_BIO_read_16},
  681.     {"BIO_read_24", AMX_BIO_read_24},
  682.     {"BIO_read_32", AMX_BIO_read_32},
  683.     {"BIO_write_8", AMX_BIO_write_8},
  684.     {"BIO_write_16", AMX_BIO_write_16},
  685.     {"BIO_write_24", AMX_BIO_write_24},
  686.     {"BIO_write_32", AMX_BIO_write_32},
  687.     {"BIO_read_8_arr", AMX_BIO_read_8_arr},
  688.     {"BIO_read_16_arr", AMX_BIO_read_16_arr},
  689.     {"BIO_read_24_arr", AMX_BIO_read_24_arr},
  690.     {"BIO_read_32_arr", AMX_BIO_read_32_arr},
  691.     {"BIO_write_8_arr", AMX_BIO_write_8_arr},
  692.     {"BIO_write_16_arr", AMX_BIO_write_16_arr},
  693.     {"BIO_write_24_arr", AMX_BIO_write_24_arr},
  694.     {"BIO_write_32_arr", AMX_BIO_write_32_arr},
  695.     {"BIO_eof", AMX_BIO_eof},
  696.     {"BIO_INST_open", AMX_BIO_INST_open},
  697.     {"BIO_INST_temp", AMX_BIO_INST_temp},
  698.     {"BIO_INST_read_8", AMX_BIO_INST_read_8},
  699.     {"BIO_INST_read_16", AMX_BIO_INST_read_16},
  700.     {"BIO_INST_read_24", AMX_BIO_INST_read_24},
  701.     {"BIO_INST_read_32", AMX_BIO_INST_read_32},
  702.     {"BIO_INST_write_8", AMX_BIO_INST_write_8},
  703.     {"BIO_INST_write_16", AMX_BIO_INST_write_16},
  704.     {"BIO_INST_write_24", AMX_BIO_INST_write_24},
  705.     {"BIO_INST_write_32", AMX_BIO_INST_write_32},
  706.     {"BIO_INST_read_8_arr", AMX_BIO_INST_read_8_arr},
  707.     {"BIO_INST_read_16_arr", AMX_BIO_INST_read_16_arr},
  708.     {"BIO_INST_read_24_arr", AMX_BIO_INST_read_24_arr},
  709.     {"BIO_INST_read_32_arr", AMX_BIO_INST_read_32_arr},
  710.     {"BIO_INST_write_8_arr", AMX_BIO_INST_write_8_arr},
  711.     {"BIO_INST_write_16_arr", AMX_BIO_INST_write_16_arr},
  712.     {"BIO_INST_write_24_arr", AMX_BIO_INST_write_24_arr},
  713.     {"BIO_INST_write_32_arr", AMX_BIO_INST_write_32_arr},
  714.     {"BIO_INST_eof", AMX_BIO_INST_eof},
  715.     {0, 0}
  716. };
  717.  
  718. PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX *amx)
  719. {
  720.     B_IO_AMX_STRUCT t_b_io_amx_vect;
  721.     t_b_io_amx_vect.amx_ptr = amx;
  722.     t_b_io_amx_vect.current_file_handle = NULL;
  723.     b_io_amx_vect.push_back(t_b_io_amx_vect);
  724.     return amx_Register(amx, PluginNatives, -1);
  725. }
  726.  
  727. PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX *amx)
  728. {
  729.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  730.     {
  731.         if(amx_it->amx_ptr != amx) continue;
  732.         b_io_amx_vect.erase(amx_it);
  733.         break;
  734.     }
  735.     return AMX_ERR_NONE;
  736. }
  737.  
  738. PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()
  739. {
  740.     vector_foreach(B_IO_AMX_STRUCT, b_io_amx_vect, amx_it)
  741.     {
  742.         if(amx_it->current_file_handle)
  743.         {
  744.             fclose(amx_it->current_file_handle);
  745.             amx_it->current_file_handle = NULL;
  746.         }
  747.     }
  748. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!