SHARE
TWEET

main.cpp - memory

BigETI Jul 11th, 2013 (edited) 263 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.         Memory access plugin made by BigETI © 2013
  3. */
  4.  
  5. //#define SECURE_MEMORY_PLUGIN
  6.  
  7. #include <string.h>
  8. #include <ctime>
  9. #include <cstdlib>
  10. #include "SDK/plugin.h"
  11.  
  12. typedef void(*logprintf_t)(char* format, ...);
  13. logprintf_t logprintf;
  14. extern void *pAMXFunctions;
  15.  
  16. class MemClass
  17. {
  18. private:
  19.         cell *ptr;
  20.         size_t len;
  21. public:
  22.         MemClass(size_t _len, bool zero = false)
  23.         {
  24.                 ptr = zero ? ((cell *)calloc(_len, sizeof(cell))) : ((cell *)malloc(_len * sizeof(cell)));
  25.                 if (ptr == NULL) throw - 1;
  26.                 len = _len;
  27.         }
  28.  
  29.         ~MemClass()
  30.         {
  31.                 free(ptr);
  32.         }
  33.  
  34.         cell *realloc(size_t _len)
  35.         {
  36.                 cell *ret = (cell *)::realloc(ptr, _len * sizeof(cell));
  37.                 if (ret)
  38.                 {
  39.                         ptr = ret;
  40.                         len = _len;
  41.                 }
  42.                 else throw - 1;
  43.                 return ret;
  44.         }
  45.  
  46.         cell &operator[](size_t index)
  47.         {
  48.                 if (index >= len) throw - 1;
  49.                 return ptr[index];
  50.         }
  51.  
  52.         size_t count()
  53.         {
  54.                 return len;
  55.         }
  56.  
  57.         cell *get_ptr()
  58.         {
  59.                 return ptr;
  60.         }
  61. };
  62. typedef MemClass*       PMemClass;
  63.  
  64. #ifdef SECURE_MEMORY_PLUGIN
  65. #       include "p_mem_class_ctr.h"
  66. #endif
  67.  
  68. using namespace std;
  69.  
  70. #ifdef SECURE_MEMORY_PLUGIN
  71.         #define list_foreach(_type,_list,_var)  for(list<_type>::iterator (_var)=(_list).begin();(_var)!=(_list).end();++(_var))
  72.  
  73. enum MEM_RESULT_ENUM
  74. {
  75.         MEM_RESULT_OK,
  76.         MEM_RESULT_NO_ALLOC,
  77.         MEM_RESULT_INVALID_PTR,
  78.         MEM_RESULT_NEG_INDEX,
  79.         MEM_RESULT_INVALID_INDEX,
  80.         MEM_RESULT_NULL_ARR,
  81.         MEM_RESULT_INVALID_SIZE,
  82.         MEM_RESULT_INVALID_OPERATION
  83. } mem_result;
  84.  
  85. static PMemClassCTR addresses;
  86. #endif
  87.  
  88. #define SWAP_VAR(var1,var2)     (var1^=(var2^=(var1^=var2)))
  89.  
  90. enum MEM_SORT_TYPE_ENUM
  91. {
  92.         MEM_SORT_TYPE_DEFAULT,
  93.         MEM_SORT_TYPE_REVERSE
  94. };
  95.  
  96. // native Pointer:MEM_malloc(cells = 1);
  97. cell AMX_NATIVE_CALL AMX_MEM_malloc(AMX *amx, cell *params)
  98. {
  99. #ifdef SECURE_MEMORY_PLUGIN
  100.         PMemClass ret = NULL;
  101.         cell *buf = NULL;
  102.         try
  103.         {
  104.                 ret = new MemClass(params[1]);
  105.         }
  106.         catch (...)
  107.         {
  108.                 ret = NULL;
  109.         }
  110.         if (ret)
  111.         {
  112.                 try
  113.                 {
  114.                         addresses.push_back(ret);
  115.                 }
  116.                 catch (...)
  117.                 {
  118.                         mem_result = MEM_RESULT_NO_ALLOC;
  119.                         delete ret;
  120.                         ret = NULL;
  121.                 }
  122.         }
  123.         else
  124.         {
  125.                 mem_result = MEM_RESULT_NO_ALLOC;
  126.                 logprintf(" [Memory Plugin] MEM_malloc(): Failed to allocate memory: %d bytes", params[1] * sizeof(cell));
  127.                 return NULL;
  128.         }
  129.         return (cell)ret;
  130. #else
  131.         return (cell)malloc((size_t)params[1]*sizeof(cell));
  132. #endif
  133. }
  134.  
  135. // native Pointer:MEM_calloc(cells = 1);
  136. cell AMX_NATIVE_CALL AMX_MEM_calloc(AMX *amx, cell *params)
  137. {
  138. #ifdef SECURE_MEMORY_PLUGIN
  139.         MemClass *ret;
  140.         try
  141.         {
  142.                 ret = new MemClass(params[1], true);
  143.         }
  144.         catch (...)
  145.         {
  146.                 ret = NULL;
  147.         }
  148.         if (ret)
  149.         {
  150.                 try
  151.                 {
  152.                         addresses.push_back(ret);
  153.                 }
  154.                 catch (...)
  155.                 {
  156.                         mem_result = MEM_RESULT_NO_ALLOC;
  157.                         delete ret;
  158.                         ret = NULL;
  159.                 }
  160.         }
  161.         else
  162.         {
  163.                 mem_result = MEM_RESULT_NO_ALLOC;
  164.                 logprintf(" [Memory Plugin] MEM_calloc(): Failed to allocate memory: %d bytes", params[1] * sizeof(cell));
  165.                 return NULL;
  166.         }
  167.         return (cell)ret;
  168. #else
  169.         return (cell)calloc((size_t)params[1], sizeof(cell));
  170. #endif
  171. }
  172.  
  173. // native Pointer:MEM_realloc(Pointer:pointer, cells = 1)
  174. cell AMX_NATIVE_CALL AMX_MEM_realloc(AMX *amx, cell *params)
  175. {
  176. #ifdef SECURE_MEMORY_PLUGIN
  177.         /*addr_temp.addr = realloc((void *)params[1], (addr_temp.len = (size_t)params[2])*sizeof(cell));
  178.         if(addr_temp.addr == NULL)
  179.         {
  180.                 mem_result = MEM_RESULT_NO_ALLOC;
  181.                 logprintf(" [Memory Plugin] MEM_realloc(): Failed to re-allocate memory from 0x%x: %d bytes", (size_t)params[1], addr_temp.len*sizeof(cell));
  182.                 return NULL;
  183.         }
  184.         addr_vect.push_back(addr_temp);
  185.         return (cell)addr_temp.addr;*/
  186.         MemClass *ret = (PMemClass)(params[1]);
  187.         if (addresses.exists(ret))
  188.         {
  189.                 if (ret->realloc(params[2]) == NULL) ret = NULL;
  190.         }
  191.         else
  192.         {
  193.                 try
  194.                 {
  195.                         ret = new MemClass(params[2], true);
  196.                 }
  197.                 catch (...)
  198.                 {
  199.                         ret = NULL;
  200.                 }
  201.                 if (ret)
  202.                 {
  203.                         try
  204.                         {
  205.                                 addresses.push_back(ret);
  206.                         }
  207.                         catch (...)
  208.                         {
  209.                                 mem_result = MEM_RESULT_NO_ALLOC;
  210.                                 delete ret;
  211.                                 ret = NULL;
  212.                         }
  213.                 }
  214.                 else
  215.                 {
  216.                         mem_result = MEM_RESULT_NO_ALLOC;
  217.                         logprintf(" [Memory Plugin] MEM_realloc(): Failed to allocate memory: %d bytes", params[1] * sizeof(cell));
  218.                         ret = NULL;
  219.                 }
  220.         }
  221.         return (cell)ret;
  222. #else
  223.         return (cell)realloc((void *)params[1], (size_t)params[2]*sizeof(cell));
  224. #endif
  225. }
  226.  
  227. // native MEM_free(Pointer:pointer);
  228. cell AMX_NATIVE_CALL AMX_MEM_free(AMX *amx, cell *params)
  229. {
  230. #ifdef SECURE_MEMORY_PLUGIN
  231.         /*vector_foreach(ADDR_STRUCT, addr_vect, addr_it)
  232.         {
  233.                 if(addr_it->addr != (void *)params[1]) continue;
  234.                 free(addr_it->addr);
  235.                 addr_vect.erase(addr_it);
  236.                 return 0;
  237.         }*/
  238.         MemClass *buf = (PMemClass)(params[1]);
  239.         if (addresses.exists(buf))
  240.         {
  241.                 addresses.erase(buf);
  242.                 delete buf;
  243.         }
  244.         else mem_result = MEM_RESULT_INVALID_PTR;
  245. #else
  246.         free((void *)(params[1]));
  247. #endif
  248.         return 0;
  249. }
  250.  
  251. // native MEM_get_val(Pointer:pointer, index = 0);
  252. cell AMX_NATIVE_CALL AMX_MEM_get_val(AMX *amx, cell *params)
  253. {
  254. #ifdef SECURE_MEMORY_PLUGIN
  255.         cell ret = 0;
  256.         PMemClass buf = (PMemClass)(params[1]);
  257.         if (addresses.exists(buf))
  258.         {
  259.                 try
  260.                 {
  261.                         ret = (*buf)[params[2]];
  262.                 }
  263.                 catch (...)
  264.                 {
  265.                         mem_result = (params[2] < 0) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  266.                 }
  267.         }
  268.         else mem_result = MEM_RESULT_INVALID_PTR;
  269.         return ret;
  270. #else
  271.         return *(cell *)((size_t)params[1]+(params[2]*sizeof(cell)));
  272. #endif
  273. }
  274.  
  275. // native Pointer:MEM_get_arr(Pointer:pointer, index = 0, arr[], arr_size = sizeof arr);
  276. cell AMX_NATIVE_CALL AMX_MEM_get_arr(AMX *amx, cell *params)
  277. {
  278.         cell *ret;
  279. #ifdef SECURE_MEMORY_PLUGIN
  280.         PMemClass buf = (PMemClass)(params[1]);
  281.         amx_GetAddr(amx, params[3], &ret);
  282.         if (params[4] > 0)
  283.         {
  284.                 if (addresses.exists(buf))
  285.                 {
  286.                         if (buf->count() >= (((size_t)(params[2])) + ((size_t)(params[4]))))
  287.                         {
  288.                                 try
  289.                                 {
  290.                                         memcpy(ret, &((*buf)[params[2]]), params[4] * sizeof(cell));
  291.                                 }
  292.                                 catch (...)
  293.                                 {
  294.                                         mem_result = (params[2] < 0) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  295.                                 }
  296.                         }
  297.                         else mem_result = MEM_RESULT_INVALID_SIZE;
  298.                 }
  299.                 else mem_result = MEM_RESULT_INVALID_PTR;
  300.         }
  301.         else
  302.         {
  303.                 mem_result = MEM_RESULT_NULL_ARR;
  304.                 ret = NULL;
  305.         }
  306. #else
  307.         amx_GetAddr(amx, params[3], &ret);
  308.         memcpy(ret, (void *)((size_t)params[1]+(size_t)params[2]*sizeof(cell)), params[4]*sizeof(cell));
  309. #endif
  310.         return (cell)ret;
  311. }
  312.  
  313. // native MEM_set_val(Pointer:pointer, index = 0, value);
  314. cell AMX_NATIVE_CALL AMX_MEM_set_val(AMX *amx, cell *params)
  315. {
  316. #ifdef SECURE_MEMORY_PLUGIN
  317.         PMemClass buf = (PMemClass)(params[1]);
  318.         if (addresses.exists(buf))
  319.         {
  320.                 try
  321.                 {
  322.                         (*buf)[params[2]] = params[3];
  323.                 }
  324.                 catch (...)
  325.                 {
  326.                         mem_result = (params[2] < 0) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  327.                 }
  328.         }
  329.         else mem_result = MEM_RESULT_INVALID_PTR;
  330.         return params[3];
  331. #endif
  332.         return *(cell *)((size_t)params[1]+(params[2]*sizeof(cell))) = params[3];
  333. }
  334.  
  335. // native Pointer:MEM_set_arr(Pointer:pointer, index = 0, const arr[], arr_size = sizeof arr);
  336. cell AMX_NATIVE_CALL AMX_MEM_set_arr(AMX *amx, cell *params)
  337. {
  338.         cell *ret;
  339. #ifdef SECURE_MEMORY_PLUGIN
  340.         PMemClass buf = (PMemClass)(params[1]);
  341.         amx_GetAddr(amx, params[3], &ret);
  342.         if (params[4] > 0)
  343.         {
  344.                 if (addresses.exists(buf))
  345.                 {
  346.                         if (buf->count() >= (((size_t)(params[2])) + ((size_t)(params[4]))))
  347.                         {
  348.                                 try
  349.                                 {
  350.                                         memcpy(&((*buf)[params[2]]), ret, params[4] * sizeof(cell));
  351.                                 }
  352.                                 catch (...)
  353.                                 {
  354.                                         mem_result = (params[2] < 0) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  355.                                 }
  356.                         }
  357.                         else
  358.                         {
  359.                                 mem_result = MEM_RESULT_INVALID_SIZE;
  360.                                 ret = NULL;
  361.                         }
  362.                 }
  363.                 else
  364.                 {
  365.                         mem_result = MEM_RESULT_INVALID_PTR;
  366.                         ret = NULL;
  367.                 }
  368.         }
  369.         else
  370.         {
  371.                 mem_result = MEM_RESULT_NULL_ARR;
  372.                 ret = NULL;
  373.         }
  374. #else
  375.         amx_GetAddr(amx, params[3], &ret);
  376.         memcpy((void *)((size_t)params[1]+(params[2]*sizeof(cell))), ret, params[4]*sizeof(cell));
  377. #endif
  378.         return (cell)ret;
  379. }
  380.  
  381. // native Pointer:MEM_copy(Pointer:dest, Pointer:src, size, dest_index = 0, src_index = 0);
  382. cell AMX_NATIVE_CALL AMX_MEM_copy(AMX *amx, cell *params)
  383. {
  384. #ifdef SECURE_MEMORY_PLUGIN
  385.         PMemClass ret = NULL;
  386.         PMemClass buf1 = (PMemClass)(params[1]), buf2 = (PMemClass)(params[2]);
  387.         if (params[3] > 0)
  388.         {
  389.                 if (addresses.exists(buf1) && addresses.exists(buf2))
  390.                 {
  391.                         if ((buf1->count() >= (((size_t)(params[3])) + ((size_t)(params[4])))) && (buf2->count() >= (((size_t)(params[3])) + ((size_t)(params[5])))))
  392.                         {
  393.                                 try
  394.                                 {
  395.                                         memcpy(&((*buf1)[params[4]]), &((*buf2)[params[5]]), params[3] * sizeof(cell));
  396.                                         ret = buf1;
  397.                                 }
  398.                                 catch (...)
  399.                                 {
  400.                                         mem_result = ((params[4] < 0) || (params[5] < 0)) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  401.                                 }
  402.                         }
  403.                         else mem_result = MEM_RESULT_INVALID_SIZE;
  404.                 }
  405.                 else mem_result = MEM_RESULT_INVALID_PTR;
  406.         }
  407.         else mem_result = MEM_RESULT_INVALID_SIZE;
  408.         return (cell)ret;
  409. #else
  410.         return (cell)(memcpy((void *)((size_t)params[1]+((size_t)params[4]*sizeof(cell))), (void *)((size_t)params[2]+((size_t)params[5]*sizeof(cell))), (size_t)params[3]*sizeof(cell)));
  411. #endif
  412. }
  413.  
  414. // native MEM_zero(Pointer:pointer, size, index = 0);
  415. cell AMX_NATIVE_CALL AMX_MEM_zero(AMX *amx, cell *params)
  416. {
  417. #ifdef SECURE_MEMORY_PLUGIN
  418.         PMemClass ret = (PMemClass)(params[1]);
  419.         if (params[2] > 0)
  420.         {
  421.                 if (addresses.exists(ret))
  422.                 {
  423.                         if (ret->count() >= (((size_t)(params[2])) + ((size_t)(params[3]))))
  424.                         {
  425.                                 try
  426.                                 {
  427.                                         memset(&((*ret)[params[3]]), 0, params[2] * sizeof(cell));
  428.                                 }
  429.                                 catch (...)
  430.                                 {
  431.                                         mem_result = (params[3] < 0) ? MEM_RESULT_NEG_INDEX : MEM_RESULT_INVALID_INDEX;
  432.                                         ret = NULL;
  433.                                 }
  434.                         }
  435.                         else
  436.                         {
  437.                                 mem_result = MEM_RESULT_INVALID_SIZE;
  438.                                 ret = NULL;
  439.                         }
  440.                 }
  441.                 else
  442.                 {
  443.                         mem_result = MEM_RESULT_INVALID_PTR;
  444.                         ret = NULL;
  445.                 }
  446.         }
  447.         else
  448.         {
  449.                 mem_result = MEM_RESULT_INVALID_SIZE;
  450.                 logprintf(" [Memory Plugin] MEM_zero(): Less than 1 cell to set zero. Amount: %d", params[2]);
  451.                 return 0;
  452.         }
  453.         return (cell)ret;
  454.         //if(!mem_is((void *)params[1], params[3]+(params[2]-1))) return 0;
  455. #else
  456.         return (cell)(memset((void *)((size_t)params[1]+((size_t)params[3]*sizeof(cell))), 0, (size_t)params[2]*sizeof(cell)));
  457. #endif
  458. }
  459.  
  460. // native Pointer:MEM_get_addr(&var);
  461. cell AMX_NATIVE_CALL AMX_MEM_get_addr(AMX *amx, cell *params)
  462. {
  463.         cell *ret;
  464.         amx_GetAddr(amx, params[1], &ret);
  465.         return (cell)ret;
  466. }
  467.  
  468. // native bool:MEM_sort(Pointer:pointer, index = 0, cells = 2, MEM_E_sort_type:sort = MEM_ENUM_sort_default);
  469. cell AMX_NATIVE_CALL AMX_MEM_sort(AMX *amx, cell *params)
  470. {
  471.         cell ret = 0;
  472.         bool allow_repeat = true;
  473.         size_t i, size = ((size_t)params[3] - 1);
  474. #ifdef SECURE_MEMORY_PLUGIN
  475.         PMemClass buf = (PMemClass)(params[1]);
  476.         cell *ptr = NULL;
  477. #else
  478.         cell *ptr = ((cell *)params[1] + (params[2] * sizeof(cell)));
  479. #endif
  480.         if (params[3] > 2)
  481.         {
  482. #ifdef SECURE_MEMORY_PLUGIN
  483.                 if (addresses.exists(buf))
  484.                 {
  485.                         if (buf->count() >= (((size_t)(params[2])) + ((size_t)(params[3]))))
  486.                         {
  487.                                 if (params[2] >= 0)
  488.                                 {
  489.                                         ptr = buf->get_ptr();
  490. #endif
  491.                                         switch ((MEM_SORT_TYPE_ENUM)params[4])
  492.                                         {
  493.                                         case MEM_SORT_TYPE_DEFAULT:
  494.                                                 while (allow_repeat)
  495.                                                 {
  496.                                                         allow_repeat = false;
  497.                                                         for (i = 0; i < size; i++)
  498.                                                         {
  499.                                                                 if (ptr[i] <= ptr[i + 1]) continue;
  500.                                                                 allow_repeat = true;
  501.                                                                 SWAP_VAR(ptr[i], ptr[i + 1]);
  502.                                                         }
  503.                                                 }
  504.                                                 break;
  505.                                         case MEM_SORT_TYPE_REVERSE:
  506.                                                 while (allow_repeat)
  507.                                                 {
  508.                                                         allow_repeat = false;
  509.                                                         for (i = 0; i < size; i++)
  510.                                                         {
  511.                                                                 if (ptr[i] >= ptr[i + 1]) continue;
  512.                                                                 allow_repeat = true;
  513.                                                                 SWAP_VAR(ptr[i], ptr[i + 1]);
  514.                                                         }
  515.                                                 }
  516.                                                 break;
  517.                                         default:
  518.                                                 logprintf(" [Memory Plugin] MEM_sort(): Wrong sort type ID %d", params[4]);
  519.                                                 return 0;
  520.                                         }
  521. #if defined SECURE_MEMORY_PLUGIN
  522.                                 }
  523.                                 else
  524.                                 {
  525.                                         mem_result = MEM_RESULT_INVALID_INDEX;
  526.                                 }
  527.                         }
  528.                         else
  529.                         {
  530.                                 mem_result = MEM_RESULT_INVALID_SIZE;
  531.                         }
  532.                 }
  533.                 else
  534.                 {
  535.                         mem_result = MEM_RESULT_INVALID_PTR;
  536.                 }
  537. #endif
  538.         }
  539.         else
  540.         {
  541. #ifdef SECURE_MEMORY_PLUGIN
  542.                 mem_result = MEM_RESULT_INVALID_OPERATION;
  543. #endif
  544.                 logprintf(" [Memory Plugin] MEM_sort(): Less than 2 cells to sort. Amount: %d", params[3]);
  545.         }
  546.         return ret;
  547. }
  548.  
  549. // native bool:MEM_mix(Pointer:pointer, index = 0, cells = 2, mix_times = 5);
  550. cell AMX_NATIVE_CALL AMX_MEM_mix(AMX *amx, cell *params)
  551. {
  552.         cell ret = 0, *mix_arr = NULL, *addr = NULL, i, j, k, id;
  553. #ifdef SECURE_MEMORY_PLUGIN
  554.         PMemClass buf = (PMemClass)(params[1]);
  555. #endif
  556.         if (params[3] >= 2)
  557.         {
  558.                 if (params[4] >= 2)
  559.                 {
  560. #ifdef SECURE_MEMORY_PLUGIN
  561.                         if (params[2] > 0)
  562.                         {
  563.                                 if (addresses.exists(buf))
  564.                                 {
  565.                                         if (buf->count() >= (((size_t)(params[2])) + ((size_t)(params[3]))))
  566.                                         {
  567.                                                 addr = buf->get_ptr();
  568. #else
  569.                                                 addr = (cell *)(params[1] + (params[2] * sizeof(cell)));
  570. #endif
  571.                                                 try
  572.                                                 {
  573.                                                         mix_arr = new cell[params[3]];
  574.                                                 }
  575.                                                 catch (...)
  576.                                                 {
  577.                                                         mix_arr = NULL;
  578.                                                 }
  579.                                                 if (mix_arr)
  580.                                                 {
  581.  
  582.                                                         for (i = 0; i < params[4]; i++)
  583.                                                         {
  584.                                                                 for (j = 0; j < params[3]; j++) mix_arr[j] = addr[j];
  585.                                                                 for (j = (params[3] - 1); j >= 0; j--)
  586.                                                                 {
  587.                                                                         addr[j] = mix_arr[id = (rand() % (j + 1))];
  588.                                                                         for (k = id; k < (params[3] - 1); k++) mix_arr[k] = mix_arr[k + 1];
  589.                                                                 }
  590.                                                         }
  591.                                                         delete[] mix_arr;
  592.                                                         ret = 1;
  593.                                                 }
  594.                                                 else
  595.                                                 {
  596. #ifdef SECURE_MEMORY_PLUGIN
  597.                                                         mem_result = MEM_RESULT_INVALID_OPERATION;
  598. #endif
  599.                                                         logprintf(" [Memory Plugin] MEM_mix(): Failed to mix memory due to lack of memory. %d bytes", params[3] * sizeof(cell));
  600.                                                 }
  601. #ifdef SECURE_MEMORY_PLUGIN
  602.                                         }
  603.                                         else mem_result = MEM_RESULT_INVALID_SIZE;
  604.                                 }
  605.                                 else mem_result = MEM_RESULT_INVALID_PTR;
  606.                         }
  607.                         else mem_result = MEM_RESULT_NEG_INDEX;
  608. #endif
  609.                 }
  610.                 else logprintf(" [Memory Plugin] MEM_mix(): Less than 1 time to mix. Times: %d", params[4]);
  611.         }
  612.         else logprintf(" [Memory Plugin] MEM_mix(): Less than 2 cells to mix. Amount: %d", params[3]);
  613.         return ret;
  614. }
  615.  
  616. // native Pointer:MEM_amx_ptr();
  617. cell AMX_NATIVE_CALL AMX_MEM_amx_ptr(AMX *amx, cell *params)
  618. {
  619.         return (cell)amx;
  620. }
  621.  
  622. #ifdef SECURE_MEMORY_PLUGIN
  623. // native MEM_is(Pointer:pointer, index = 0);
  624. cell AMX_NATIVE_CALL AMX_MEM_is(AMX *amx, cell *params)
  625. {
  626.         return addresses.exists((PMemClass)(params[1])) ? ((params[2] < 0) ? 0 : ((cell)(((PMemClass)(params[1]))->count() > (size_t)(params[2])))) : 0;
  627. }
  628.  
  629. // native MEM_len(Pointer:pointer);
  630. cell AMX_NATIVE_CALL AMX_MEM_len(AMX *amx, cell *params)
  631. {
  632.         cell ret = 0;
  633.         if (addresses.exists((PMemClass)(params[1]))) ret = ((PMemClass)(params[1]))->count();
  634.         return ret;
  635. }
  636.  
  637. // native MEM_E_res:MEM_result(bool:free_result = true);
  638. cell AMX_NATIVE_CALL AMX_MEM_result(AMX *amx, cell *params)
  639. {
  640.         cell ret = (cell)mem_result;
  641.         if(params[1]) mem_result = MEM_RESULT_OK;
  642.         return ret;
  643. }
  644. #endif
  645.  
  646. PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports()
  647. {
  648.         return SUPPORTS_VERSION|SUPPORTS_AMX_NATIVES;
  649. }
  650.  
  651. PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData)
  652. {
  653.         pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
  654.         logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
  655.         srand((unsigned int)time(NULL));
  656.         logprintf("========================");
  657.         logprintf("= Memory access plugin =");
  658.         logprintf("=       Made by BigETI =");
  659.         logprintf("= Loaded!              =");
  660.         logprintf("========================");
  661.         return true;
  662. }
  663.  
  664. PLUGIN_EXPORT void PLUGIN_CALL Unload()
  665. {
  666. #ifdef SECURE_MEMORY_PLUGIN
  667.         list_foreach(PMemClass, addresses._list, it) delete (*it);
  668.         addresses.clear();
  669. #endif
  670.         logprintf("========================");
  671.         logprintf("= Memory access plugin =");
  672.         logprintf("=       Made by BigETI =");
  673.         logprintf("= Unloaded!            =");
  674.         logprintf("========================");
  675. }
  676.  
  677. AMX_NATIVE_INFO PluginNatives[] =
  678. {
  679.         {"MEM_malloc", AMX_MEM_malloc},
  680.         {"MEM_calloc", AMX_MEM_calloc},
  681.         {"MEM_realloc", AMX_MEM_realloc},
  682.         {"MEM_free", AMX_MEM_free},
  683.         {"MEM_get_val", AMX_MEM_get_val},
  684.         {"MEM_get_arr", AMX_MEM_get_arr},
  685.         {"MEM_set_val", AMX_MEM_set_val},
  686.         {"MEM_set_arr", AMX_MEM_set_arr},
  687.         {"MEM_copy", AMX_MEM_copy},
  688.         {"MEM_zero", AMX_MEM_zero},
  689.         {"MEM_get_addr", AMX_MEM_get_addr},
  690.         {"MEM_sort", AMX_MEM_sort},
  691.         {"MEM_mix", AMX_MEM_mix},
  692.         {"MEM_amx_ptr", AMX_MEM_amx_ptr},
  693. #ifdef SECURE_MEMORY_PLUGIN
  694.         {"MEM_is", AMX_MEM_is},
  695.         {"MEM_len", AMX_MEM_len},
  696.         {"MEM_result", AMX_MEM_result},
  697. #endif
  698.         {0, 0}
  699. };
  700.  
  701. PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX *amx)
  702. {
  703.         return amx_Register(amx, PluginNatives, -1);
  704. }
  705.  
  706. PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX *amx)
  707. {
  708.         return AMX_ERR_NONE;
  709. }
RAW Paste Data
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
 
Top