API tools faq
paste
Advertisement
BigETI

main.cpp - memory

BigETI
Jul 11th, 2013
440
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.30 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!