API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 12th, 2021
434
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 57.23 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <fcntl.h>
  5. #include <dirent.h>
  6. #include <pthread.h>
  7.  
  8. struct MAPS
  9. {
  10.     long int addr;
  11.     long int taddr;
  12.     struct MAPS *next;
  13. };
  14.  
  15. struct RESULT
  16. {
  17.     long int addr;
  18.     struct RESULT *next;
  19. };
  20.  
  21. struct FREEZE
  22. {
  23.     long int addr;       //alamat
  24.     char *value;         //nilai
  25.     int type;            //Jenis dari
  26.     struct FREEZE *next; //Pointer ke node berikutnya
  27. };
  28.  
  29. #define LEN sizeof(struct MAPS)
  30. #define FRE sizeof(struct FREEZE)
  31. typedef struct MAPS *PMAPS;    //Daftar tertaut dari peta yang disimpan
  32. typedef struct RESULT *PRES;   //Tertaut daftar hasil yang disimpan
  33. typedef struct FREEZE *PFREEZE;//Daftar tertaut untuk menyimpan data beku
  34.  
  35. typedef int TYPE;
  36. typedef int RANGE;
  37. typedef int COUNT;
  38. typedef int COLOR;
  39. typedef long int OFFSET;
  40. typedef long int ADDRESS;
  41. typedef char PACKAGENAME;
  42. int handle;
  43.  
  44. enum type
  45. {
  46.     DWORD,
  47.     FLOAT
  48. };
  49.  
  50. enum Range
  51. {
  52.     ALL,        //Semua memori
  53.     B_BAD,      //Memori B
  54.     V,      //Memori video
  55.     C_ALLOC,    //Memori Ca
  56.     C_BSS,      //Memori Cb
  57.     C_DATA,     //Memori Cd
  58.     C_HEAP,     //Memori ch
  59.     JAVA_HEAP,  //Memori Jh
  60.     A_ANONMYOUS,//Memori A
  61.     CODE_SYSTEM,//Memori xs
  62.     STACK,      //S memory
  63.     ASHMEM,    //Sebagai memori
  64.     CODE_APP, // Memori Xa
  65.     OTHER
  66. };
  67.  
  68. enum Color
  69. {
  70.     COLOR_SILVERY,    //Perak
  71.     COLOR_RED,        //merah
  72.     COLOR_GREEN,      //hijau
  73.     COLOR_YELLOW,     //kuning
  74.     COLOR_DARK_BLUE,  //biru
  75.     COLOR_PINK,       //Merah Jambu
  76.     COLOR_SKY_BLUE,   //Langit biru
  77.     COLOR_WHITE       //putih
  78. };
  79.  
  80. PMAPS Res=NULL;//Penggemar global (tempat data disimpan)
  81.  
  82. PFREEZE Pfreeze=NULL;//Digunakan untuk menyimpan data beku
  83. PFREEZE pEnd=NULL;
  84. PFREEZE pNew=NULL;
  85. int FreezeCount=0;//Jumlah data beku
  86. int Freeze=0;//beralih
  87. pthread_t pth;
  88. char Fbm[64];//Nama paket
  89. long int delay=30000;//Tunda pembekuan, default 30000us
  90.  
  91. int ResCount=0;//Jumlah hasil
  92. int MemorySearchRange=0;//0 untuk semua
  93.  
  94. int SetTextColor(int color);
  95. int getRoot(char *argv[]);//Dapatkan izin root
  96. int getPID(char bm[64]);//Dapatkan pid
  97.  
  98. int SetSearchRange(int type);//Tetapkan lingkup pencarian
  99. PMAPS readmaps(char *bm, int type);
  100. PMAPS readmaps_all(char *bm);
  101. PMAPS readmaps_bad(char *bm);
  102. PMAPS readmaps_v(char *bm);
  103. PMAPS readmaps_c_alloc(char *bm);
  104. PMAPS readmaps_c_bss(char *bm);
  105. PMAPS readmaps_c_data(char *bm);
  106. PMAPS readmaps_c_heap(char *bm);
  107. PMAPS readmaps_java_heap(char *bm);
  108. PMAPS readmaps_a_anonmyous(char *bm);
  109. PMAPS readmaps_code_system(char *bm);
  110. PMAPS readmaps_stack(char *bm);
  111. PMAPS readmaps_ashmem(char *bm);
  112. PMAPS readmaps_code_app(char *bm);
  113. PMAPS readmaps_other(char *bm);
  114. //PMAPS readmaps_il2cpp(char *bm);
  115.  
  116. void BaseAddressSearch(char *bm,char *value,int *gs,int type,long int BaseAddr);//Pencarian basis
  117. PMAPS BaseAddressSearch_DWORD(char *bm,int value,int *gs,long int BaseAddr,PMAPS pMap);//DWORD
  118. PMAPS BaseAddressSearch_FLOAT(char *bm,float value,int *gs,long int BaseAddr,PMAPS pMap);//FLOAT
  119.  
  120. void RangeMemorySearch(char *bm,char *from_value,char *to_value,int *gs,int type);//Rentang pencarian
  121. PMAPS RangeMemorySearch_DWORD(char *bm,int from_value,int to_value,int *gs,PMAPS pMap);//DWORD
  122. PMAPS RangeMemorySearch_FLOAT(char *bm,float from_value,float to_value,int *gs,PMAPS pMap);//FLOAT
  123.  
  124. void MemorySearch(char *bm,char *value,int *gs,int TYPE);//类型搜索,这里value需要传入一个地址
  125. PMAPS MemorySearch_DWORD(char *bm,int value,int *gs,PMAPS pMap);  //内存搜索DWORD
  126. PMAPS MemorySearch_FLOAT(char *bm,float value,int *gs,PMAPS pMap);  //内存搜索FLOAT
  127.  
  128. void MemoryOffset(char *bm,char *value,long int offset,int *gs,int type);//搜索偏移
  129. PMAPS MemoryOffset_DWORD(char *bm,int value,long int offset,PMAPS pBuff,int *gs);//搜索偏移DWORD
  130. PMAPS MemoryOffset_FLOAT(char *bm,float value,long int offset,PMAPS pBuff,int *gs);//搜索偏移FLOAT
  131.  
  132. void RangeMemoryOffset(char *bm,char *from_value,char *to_value,long int offset,int *gs,int type);//范围偏移
  133. PMAPS RangeMemoryOffset_DWORD(char *bm,int from_value,int to_value,long int offset,PMAPS pBuff,int *gs);//搜索偏移DWORD
  134. PMAPS RangeMemoryOffset_FLOAT(char *bm,float from_value,float to_value,long int offset,PMAPS pBuff,int *gs);//搜索偏移FLOAT
  135.  
  136. void MemoryWrite(char *bm,char *value,long int offset,int type);    //内存写入
  137. int MemoryWrite_DWORD(char *bm,int value,PMAPS pBuff,long int offset);  //内存写入DWORD
  138. int MemoryWrite_FLOAT(char *bm,float value,PMAPS pBuff,long int offset);    //内存写入FLOAT
  139.  
  140. void *SearchAddress(char *bm,long int addr);//搜索地址中的值,返回一个指针
  141. int WriteAddress(char *bm,long int addr,void *value,int type);//修改地址中的值
  142. void BypassGameSafe();//绕过游戏保护
  143. //void RecBypassGameSafe(char *bm);//解除(停止使用)
  144. void Print();//打印Res里面的内容
  145. void ClearResults();//清除链表,释放空间
  146. void ClearMaps(PMAPS pMap);//清空maps
  147.  
  148. int isapkinstalled(char *bm);//检测应用是否安装
  149. int isapkrunning(char *bm);//检测应用是否运行
  150. int killprocess(char *bm);//杀掉进程
  151. char GetProcessState(char *bm);//获取进程状态
  152. int killGG();//杀掉gg修改器
  153. int killXs();//杀xs
  154. int uninstallapk(char *bm);//静默删除软件
  155. int installapk(char *lj);//静默卸载软件
  156. int rebootsystem();//重启系统(手机)
  157. int PutDate();//输出系统日期
  158. int GetDate(char *date);//获取系统时间
  159.  
  160. PMAPS GetResults();//获取结果,返回头指针
  161. int AddFreezeItem_All(char *bm,char *Value,int type,long int offset);//冻结所有结果
  162. int AddFreezeItem(char *bm,long int addr,char *value,int type,long int offset);//增加冻结数据
  163. int AddFreezeItem_DWORD(char *bm,long int addr,char *value);//DWORD
  164. int AddFreezeItem_FLOAT(char *bm,long int addr,char *value);//FLOAT
  165. int RemoveFreezeItem(long int addr);//清除固定冻结数据
  166. int RemoveFreezeItem_All();//清空所有冻结数据
  167. int StartFreeze(char *bm);//开始冻结
  168. int StopFreeze();//停止冻结
  169. int SetFreezeDelay(long int De);//设置冻结延迟
  170. int PrintFreezeItems();//打印冻结表
  171.  
  172. int SetTextColor(COLOR color)
  173. {
  174.     switch (color)
  175.     {
  176.         case COLOR_SILVERY:
  177.             printf("\033[30;1m");
  178.             break;
  179.         case COLOR_RED:
  180.             printf("\033[31;1m");
  181.             break;
  182.         case COLOR_GREEN:
  183.             printf("\033[32;1m");
  184.             break;
  185.         case COLOR_YELLOW:
  186.             printf("\033[33;1m");
  187.             break;
  188.         case COLOR_DARK_BLUE:
  189.             printf("\033[34;1m");
  190.             break;
  191.         case COLOR_PINK:
  192.             printf("\033[35;1m");
  193.             break;
  194.         case COLOR_SKY_BLUE:
  195.             printf("\033[36;1m");
  196.             break;
  197.         case COLOR_WHITE:
  198.             printf("\033[37;1m");
  199.             break;
  200.         default:
  201.             printf("\033[37;1m");
  202.             break;
  203.     }
  204.     return 0;
  205. }
  206.  
  207. int getRoot(char *argv[])
  208. {
  209.     char ml[64];
  210.     sprintf(ml,"su -c %s",*argv);
  211.     if (getuid() != 0)
  212.     {
  213.         system(ml);
  214.         exit(1);//退出没有root的进程
  215.     }
  216. }
  217.  
  218. /*int getPID(PACKAGENAME bm[64])
  219. {
  220.     FILE *fp;//文件指针
  221.     pid_t pid;//pid
  222.     char log[64];//命令
  223.     sprintf(log,"pidof %s > log.txt",bm);
  224.     system(log);//执行
  225.     if ((fp = fopen("log.txt", "r")) == NULL)
  226.     {
  227.         return -1;
  228.     }
  229.     fscanf(fp, "%d", &pid);//读取pid
  230.     remove("log.txt");
  231.     return pid;
  232. }*/
  233.  
  234. int getPID(PACKAGENAME *PackageName)
  235. {
  236.     DIR *dir=NULL;
  237.     struct dirent *ptr=NULL;
  238.     FILE *fp=NULL;
  239.     char filepath[256];         // 大小随意，能装下cmdline文件的路径即可
  240.     char filetext[128];         // 大小随意，能装下要识别的命令行文本即可
  241.     dir = opendir("/proc");     // 打开路径
  242.     if (NULL != dir)
  243.     {
  244.         while ((ptr = readdir(dir)) != NULL)    // 循环读取路径下的每一个文件/文件夹
  245.         {
  246.             // 如果读取到的是"."或者".."则跳过，读取到的不是文件夹名字也跳过
  247.             if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
  248.                 continue;
  249.             if (ptr->d_type != DT_DIR)
  250.                 continue;
  251.             sprintf(filepath, "/proc/%s/cmdline", ptr->d_name); // 生成要读取的文件的路径
  252.             fp = fopen(filepath, "r");  // 打开文件
  253.             if (NULL != fp)
  254.             {
  255.                 fgets(filetext,sizeof(filetext),fp);    // 读取文件
  256.                 if (strcmp(filetext,PackageName)==0)
  257.                 {
  258.                     //puts(filepath);
  259.                     //printf("packagename:%s\n",filetext);
  260.                     break;
  261.                 }
  262.                 fclose(fp);
  263.             }
  264.         }
  265.     }
  266.     if (readdir(dir) == NULL)
  267.     {
  268.         //puts("Get pid fail");
  269.         return 0;
  270.     }
  271.     closedir(dir);  // 关闭路径
  272.     return atoi(ptr->d_name);
  273. }
  274.  
  275. int SetSearchRange(TYPE type)
  276. {
  277.     switch (type)
  278.     {
  279.         case ALL:
  280.             MemorySearchRange=0;
  281.             break;
  282.         case B_BAD:
  283.             MemorySearchRange=1;
  284.             break;
  285.         case V:
  286.             MemorySearchRange=2;
  287.             break;
  288.         case C_ALLOC:
  289.             MemorySearchRange=3;
  290.             break;
  291.         case C_BSS:
  292.             MemorySearchRange=4;
  293.             break;
  294.         case C_DATA:
  295.             MemorySearchRange=5;
  296.             break;
  297.         case C_HEAP:
  298.             MemorySearchRange=6;
  299.             break;
  300.         case JAVA_HEAP:
  301.             MemorySearchRange=7;
  302.             break;
  303.         case A_ANONMYOUS:
  304.             MemorySearchRange=8;
  305.             break;
  306.         case CODE_SYSTEM:
  307.             MemorySearchRange=9;
  308.             break;
  309.         case STACK:
  310.             MemorySearchRange=10;
  311.             break;
  312.         case ASHMEM:
  313.             MemorySearchRange=11;
  314.             break;
  315.         case CODE_APP:
  316.         MemorySearchRange=12;
  317.         break;
  318.         case OTHER:
  319.         MemorySearchRange=13;
  320.         break;
  321.         default:
  322.             printf("\033[32;1mYou Select A NULL Type!\n");
  323.             break;
  324.     }
  325.     return 0;
  326. }
  327.  
  328. PMAPS readmaps(char* bm,TYPE type)
  329. {
  330.     PMAPS pMap=NULL;
  331.     switch (type)
  332.     {
  333.         case ALL:
  334.             pMap=readmaps_all(bm);
  335.             break;
  336.         case B_BAD:
  337.             pMap=readmaps_bad(bm);
  338.             break;
  339.         case V:
  340.             pMap = readmaps_v(bm);
  341.             break;
  342.         case C_ALLOC:
  343.             pMap=readmaps_c_alloc(bm);
  344.             break;
  345.         case C_BSS:
  346.             pMap=readmaps_c_bss(bm);
  347.             break;
  348.         case C_DATA:
  349.             pMap=readmaps_c_data(bm);
  350.             break;
  351.         case C_HEAP:
  352.             pMap=readmaps_c_heap(bm);
  353.             break;
  354.         case JAVA_HEAP:
  355.             pMap=readmaps_java_heap(bm);
  356.             break;
  357.         case A_ANONMYOUS:
  358.             pMap=readmaps_a_anonmyous(bm);
  359.             break;
  360.         case CODE_SYSTEM:
  361.             pMap=readmaps_code_system(bm);
  362.             break;
  363.         case STACK:
  364.             pMap=readmaps_stack(bm);
  365.             break;
  366.         case ASHMEM:
  367.             pMap=readmaps_ashmem(bm);
  368.             break;
  369.         case CODE_APP:
  370. pMap=readmaps_code_app(bm);
  371. break;
  372. case OTHER:
  373. pMap=readmaps_other(bm);
  374. break;
  375.         default:
  376.             printf("\033[32;1mYou Select A NULL Type!\n");
  377.             break;
  378.     }
  379.     if (pMap == NULL)
  380.     {
  381.         return 0;
  382.     }
  383.     return pMap;
  384. }
  385.  
  386. PMAPS readmaps_all(PACKAGENAME *bm)
  387. {
  388.     PMAPS pHead=NULL;
  389.     PMAPS pNew;
  390.     PMAPS pEnd;
  391.     pEnd=pNew=(PMAPS)malloc(LEN);
  392.     FILE *fp;
  393.     int i = 0,flag=1;
  394.     char lj[64], buff[256];
  395.     int pid = getPID(bm);
  396.     sprintf(lj, "/proc/%d/maps", pid);
  397.     fp = fopen(lj, "r");
  398.     if (fp == NULL)
  399.     {
  400.         puts("分析失败");
  401.         return NULL;
  402.     }
  403.     while (!feof(fp))
  404.     {
  405.         fgets(buff,sizeof(buff),fp);//读取一行
  406.         if (strstr(buff, "rw") != NULL && !feof(fp))
  407.         {
  408.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  409.             //这里使用lx是为了能成功读取特别长的地址
  410.             flag=1;
  411.         }
  412.         else
  413.         {
  414.             flag=0;
  415.         }
  416.         if (flag==1)
  417.         {
  418.             i++;
  419.             if (i==1)
  420.             {
  421.                 pNew->next=NULL;
  422.                 pEnd=pNew;
  423.                 pHead=pNew;
  424.             }
  425.             else
  426.             {
  427.                 pNew->next=NULL;
  428.                 pEnd->next=pNew;
  429.                 pEnd=pNew;
  430.             }
  431.             pNew=(PMAPS)malloc(LEN);//分配内存
  432.         }
  433.     }
  434.     free(pNew);//将多余的空间释放
  435.     fclose(fp);//关闭文件指针
  436.     return pHead;
  437. }
  438.  
  439. PMAPS readmaps_bad(PACKAGENAME *bm)
  440. {
  441.     PMAPS pHead=NULL;
  442.     PMAPS pNew=NULL;
  443.     PMAPS pEnd=NULL;
  444.     pEnd=pNew=(PMAPS)malloc(LEN);
  445.     FILE *fp;
  446.     int i = 0,flag=1;
  447.     char lj[64], buff[256];
  448.     int pid = getPID(bm);
  449.     sprintf(lj, "/proc/%d/maps", pid);
  450.     fp = fopen(lj, "r");
  451.     if (fp == NULL)
  452.     {
  453.         puts("分析失败");
  454.         return NULL;
  455.     }
  456.     while (!feof(fp))
  457.     {
  458.         fgets(buff,sizeof(buff),fp);//读取一行
  459.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"kgsl-3d0"))
  460.         {
  461.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  462.             //这里使用lx是为了能成功读取特别长的地址
  463.             flag=1;
  464.         }
  465.         else
  466.         {
  467.             flag=0;
  468.         }
  469.         if (flag==1)
  470.         {
  471.             i++;
  472.             if (i==1)
  473.             {
  474.                 pNew->next=NULL;
  475.                 pEnd=pNew;
  476.                 pHead=pNew;
  477.             }
  478.             else
  479.             {
  480.                 pNew->next=NULL;
  481.                 pEnd->next=pNew;
  482.                 pEnd=pNew;
  483.             }
  484.             pNew=(PMAPS)malloc(LEN);//分配内存
  485.         }
  486.     }
  487.     free(pNew);//将多余的空间释放
  488.     fclose(fp);//关闭文件指针
  489.     return pHead;
  490. }
  491. PMAPS readmaps_v(PACKAGENAME * bm)
  492. {
  493.     PMAPS pHead = NULL;
  494.     PMAPS pNew = NULL;
  495.     PMAPS pEnd = NULL;
  496.     pEnd = pNew = (PMAPS) malloc(LEN);
  497.     FILE *fp;
  498.     int i = 0, flag = 1;
  499.     char lj[64], buff[256];
  500.     int pid = getPID(bm);
  501.     sprintf(lj, "/proc/%d/maps", pid);
  502.     fp = fopen(lj, "r");
  503.     if (fp == NULL)
  504.     {
  505.         puts("分析失败");
  506.         return NULL;
  507.     }
  508.     while (!feof(fp))
  509.     {
  510.         fgets(buff, sizeof(buff), fp);  // 读取一行
  511.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff, "/dev/kgsl-3d0"))
  512.         {
  513.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  514.             // 这里使用lx是为了能成功读取特别长的地址
  515.             flag = 1;
  516.         }
  517.         else
  518.         {
  519.             flag = 0;
  520.         }
  521.         if (flag == 1)
  522.         {
  523.             i++;
  524.             if (i == 1)
  525.             {
  526.                 pNew->next = NULL;
  527.                 pEnd = pNew;
  528.                 pHead = pNew;
  529.             }
  530.             else
  531.             {
  532.                 pNew->next = NULL;
  533.                 pEnd->next = pNew;
  534.                 pEnd = pNew;
  535.             }
  536.             pNew = (PMAPS) malloc(LEN); // 分配内存
  537.         }
  538.     }
  539.     free(pNew);                 // 将多余的空间释放
  540.     fclose(fp);                 // 关闭文件指针
  541.     return pHead;
  542. }
  543. PMAPS readmaps_c_alloc(PACKAGENAME *bm)
  544. {
  545.     PMAPS pHead=NULL;
  546.     PMAPS pNew=NULL;
  547.     PMAPS pEnd=NULL;
  548.     pEnd=pNew=(PMAPS)malloc(LEN);
  549.     FILE *fp;
  550.     int i = 0,flag=1;
  551.     char lj[64], buff[256];
  552.     int pid = getPID(bm);
  553.     sprintf(lj, "/proc/%d/maps", pid);
  554.     fp = fopen(lj, "r");
  555.     if (fp == NULL)
  556.     {
  557.         puts("分析失败");
  558.         return NULL;
  559.     }
  560.     while (!feof(fp))
  561.     {
  562.         fgets(buff,sizeof(buff),fp);//读取一行
  563.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"[anon:libc_malloc]"))
  564.         {
  565.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  566.             //这里使用lx是为了能成功读取特别长的地址
  567.             flag=1;
  568.         }
  569.         else
  570.         {
  571.             flag=0;
  572.         }
  573.         if (flag==1)
  574.         {
  575.             i++;
  576.             if (i==1)
  577.             {
  578.                 pNew->next=NULL;
  579.                 pEnd=pNew;
  580.                 pHead=pNew;
  581.             }
  582.             else
  583.             {
  584.                 pNew->next=NULL;
  585.                 pEnd->next=pNew;
  586.                 pEnd=pNew;
  587.             }
  588.             pNew=(PMAPS)malloc(LEN);//分配内存
  589.         }
  590.     }
  591.     free(pNew);//将多余的空间释放
  592.     fclose(fp);//关闭文件指针
  593.     return pHead;
  594. }
  595.  
  596. PMAPS readmaps_c_bss(PACKAGENAME *bm)
  597. {
  598.     PMAPS pHead=NULL;
  599.     PMAPS pNew=NULL;
  600.     PMAPS pEnd=NULL;
  601.     pEnd=pNew=(PMAPS)malloc(LEN);
  602.     FILE *fp;
  603.     int i = 0,flag=1;
  604.     char lj[64], buff[256];
  605.     int pid = getPID(bm);
  606.     sprintf(lj, "/proc/%d/maps", pid);
  607.     fp = fopen(lj, "r");
  608.     if (fp == NULL)
  609.     {
  610.         puts("分析失败");
  611.         return NULL;
  612.     }
  613.     while (!feof(fp))
  614.     {
  615.         fgets(buff,sizeof(buff),fp);//读取一行
  616.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"[anon:.bss]"))
  617.         {
  618.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  619.             //这里使用lx是为了能成功读取特别长的地址
  620.             flag=1;
  621.         }
  622.         else
  623.         {
  624.             flag=0;
  625.         }
  626.         if (flag==1)
  627.         {
  628.             i++;
  629.             if (i==1)
  630.             {
  631.                 pNew->next=NULL;
  632.                 pEnd=pNew;
  633.                 pHead=pNew;
  634.             }
  635.             else
  636.             {
  637.                 pNew->next=NULL;
  638.                 pEnd->next=pNew;
  639.                 pEnd=pNew;
  640.             }
  641.             pNew=(PMAPS)malloc(LEN);//分配内存
  642.         }
  643.     }
  644.     free(pNew);//将多余的空间释放
  645.     fclose(fp);//关闭文件指针
  646.     return pHead;
  647. }
  648.  
  649. PMAPS readmaps_c_data(PACKAGENAME *bm)
  650. {
  651.     PMAPS pHead=NULL;
  652.     PMAPS pNew=NULL;
  653.     PMAPS pEnd=NULL;
  654.     pEnd=pNew=(PMAPS)malloc(LEN);
  655.     FILE *fp;
  656.     int i = 0,flag=1;
  657.     char lj[64], buff[256];
  658.     int pid = getPID(bm);
  659.     sprintf(lj, "/proc/%d/maps", pid);
  660.     fp = fopen(lj, "r");
  661.     if (fp == NULL)
  662.     {
  663.         puts("分析失败");
  664.         return NULL;
  665.     }
  666.     while (!feof(fp))
  667.     {
  668.         fgets(buff,sizeof(buff),fp);//读取一行
  669.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"/data/app/"))
  670.         {
  671.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  672.             //这里使用lx是为了能成功读取特别长的地址
  673.             flag=1;
  674.         }
  675.         else
  676.         {
  677.             flag=0;
  678.         }
  679.         if (flag==1)
  680.         {
  681.             i++;
  682.             if (i==1)
  683.             {
  684.                 pNew->next=NULL;
  685.                 pEnd=pNew;
  686.                 pHead=pNew;
  687.             }
  688.             else
  689.             {
  690.                 pNew->next=NULL;
  691.                 pEnd->next=pNew;
  692.                 pEnd=pNew;
  693.             }
  694.             pNew=(PMAPS)malloc(LEN);//分配内存
  695.         }
  696.     }
  697.     free(pNew);//将多余的空间释放
  698.     fclose(fp);//关闭文件指针
  699.     return pHead;
  700. }
  701.  
  702. PMAPS readmaps_c_heap(PACKAGENAME *bm)
  703. {
  704.     PMAPS pHead=NULL;
  705.     PMAPS pNew=NULL;
  706.     PMAPS pEnd=NULL;
  707.     pEnd=pNew=(PMAPS)malloc(LEN);
  708.     FILE *fp;
  709.     int i = 0,flag=1;
  710.     char lj[64], buff[256];
  711.     int pid = getPID(bm);
  712.     sprintf(lj, "/proc/%d/maps", pid);
  713.     fp = fopen(lj, "r");
  714.     if (fp == NULL)
  715.     {
  716.         puts("分析失败");
  717.         return NULL;
  718.     }
  719.     while (!feof(fp))
  720.     {
  721.         fgets(buff,sizeof(buff),fp);//读取一行
  722.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"[heap]"))
  723.         {
  724.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  725.             //这里使用lx是为了能成功读取特别长的地址
  726.             flag=1;
  727.         }
  728.         else
  729.         {
  730.             flag=0;
  731.         }
  732.         if (flag==1)
  733.         {
  734.             i++;
  735.             if (i==1)
  736.             {
  737.                 pNew->next=NULL;
  738.                 pEnd=pNew;
  739.                 pHead=pNew;
  740.             }
  741.             else
  742.             {
  743.                 pNew->next=NULL;
  744.                 pEnd->next=pNew;
  745.                 pEnd=pNew;
  746.             }
  747.             pNew=(PMAPS)malloc(LEN);//分配内存
  748.         }
  749.     }
  750.     free(pNew);//将多余的空间释放
  751.     fclose(fp);//关闭文件指针
  752.     return pHead;
  753. }
  754.  
  755. PMAPS readmaps_java_heap(PACKAGENAME *bm)
  756. {
  757.     PMAPS pHead=NULL;
  758.     PMAPS pNew=NULL;
  759.     PMAPS pEnd=NULL;
  760.     pEnd=pNew=(PMAPS)malloc(LEN);
  761.     FILE *fp;
  762.     int i = 0,flag=1;
  763.     char lj[64], buff[256];
  764.     int pid = getPID(bm);
  765.     sprintf(lj, "/proc/%d/maps", pid);
  766.     fp = fopen(lj, "r");
  767.     if (fp == NULL)
  768.     {
  769.         puts("分析失败");
  770.         return NULL;
  771.     }
  772.     while (!feof(fp))
  773.     {
  774.         fgets(buff,sizeof(buff),fp);//读取一行
  775.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"/dev/ashmem/"))
  776.         {
  777.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  778.             //这里使用lx是为了能成功读取特别长的地址
  779.             flag=1;
  780.         }
  781.         else
  782.         {
  783.             flag=0;
  784.         }
  785.         if (flag==1)
  786.         {
  787.             i++;
  788.             if (i==1)
  789.             {
  790.                 pNew->next=NULL;
  791.                 pEnd=pNew;
  792.                 pHead=pNew;
  793.             }
  794.             else
  795.             {
  796.                 pNew->next=NULL;
  797.                 pEnd->next=pNew;
  798.                 pEnd=pNew;
  799.             }
  800.             pNew=(PMAPS)malloc(LEN);//分配内存
  801.         }
  802.     }
  803.     free(pNew);//将多余的空间释放
  804.     fclose(fp);//关闭文件指针
  805.     return pHead;
  806. }
  807.  
  808. PMAPS readmaps_a_anonmyous(PACKAGENAME *bm)
  809. {
  810.     PMAPS pHead=NULL;
  811.     PMAPS pNew=NULL;
  812.     PMAPS pEnd=NULL;
  813.     pEnd=pNew=(PMAPS)malloc(LEN);
  814.     FILE *fp;
  815.     int i = 0,flag=1;
  816.     char lj[64], buff[256];
  817.     int pid = getPID(bm);
  818.     sprintf(lj, "/proc/%d/maps", pid);
  819.     fp = fopen(lj, "r");
  820.     if (fp == NULL)
  821.     {
  822.         puts("分析失败");
  823.         return NULL;
  824.     }
  825.     while (!feof(fp))
  826.     {
  827.         fgets(buff,sizeof(buff),fp);//读取一行
  828.         if (strstr(buff, "rw") != NULL && !feof(fp) && (strlen(buff) < 42))
  829.         {
  830.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  831.             //这里使用lx是为了能成功读取特别长的地址
  832.             flag=1;
  833.         }
  834.         else
  835.         {
  836.             flag=0;
  837.         }
  838.         if (flag==1)
  839.         {
  840.             i++;
  841.             if (i==1)
  842.             {
  843.                 pNew->next=NULL;
  844.                 pEnd=pNew;
  845.                 pHead=pNew;
  846.             }
  847.             else
  848.             {
  849.                 pNew->next=NULL;
  850.                 pEnd->next=pNew;
  851.                 pEnd=pNew;
  852.             }
  853.             pNew=(PMAPS)malloc(LEN);//分配内存
  854.         }
  855.     }
  856.     free(pNew);//将多余的空间释放
  857.     fclose(fp);//关闭文件指针
  858.     return pHead;
  859. }
  860.  
  861. PMAPS readmaps_code_system(PACKAGENAME *bm)
  862. {
  863.     PMAPS pHead=NULL;
  864.     PMAPS pNew=NULL;
  865.     PMAPS pEnd=NULL;
  866.     pEnd=pNew=(PMAPS)malloc(LEN);
  867.     FILE *fp;
  868.     int i = 0,flag=1;
  869.     char lj[64], buff[256];
  870.     int pid = getPID(bm);
  871.     sprintf(lj, "/proc/%d/maps", pid);
  872.     fp = fopen(lj, "r");
  873.     if (fp == NULL)
  874.     {
  875.         puts("分析失败");
  876.         return NULL;
  877.     }
  878.     while (!feof(fp))
  879.     {
  880.         fgets(buff,sizeof(buff),fp);//读取一行
  881.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"/system"))
  882.         {
  883.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  884.             //这里使用lx是为了能成功读取特别长的地址
  885.             flag=1;
  886.         }
  887.         else
  888.         {
  889.             flag=0;
  890.         }
  891.         if (flag==1)
  892.         {
  893.             i++;
  894.             if (i==1)
  895.             {
  896.                 pNew->next=NULL;
  897.                 pEnd=pNew;
  898.                 pHead=pNew;
  899.             }
  900.             else
  901.             {
  902.                 pNew->next=NULL;
  903.                 pEnd->next=pNew;
  904.                 pEnd=pNew;
  905.             }
  906.             pNew=(PMAPS)malloc(LEN);//分配内存
  907.         }
  908.     }
  909.     free(pNew);//将多余的空间释放
  910.     fclose(fp);//关闭文件指针
  911.     return pHead;
  912. }
  913.  
  914. PMAPS readmaps_stack(PACKAGENAME *bm)
  915. {
  916.     PMAPS pHead=NULL;
  917.     PMAPS pNew=NULL;
  918.     PMAPS pEnd=NULL;
  919.     pEnd=pNew=(PMAPS)malloc(LEN);
  920.     FILE *fp;
  921.     int i = 0,flag=1;
  922.     char lj[64], buff[256];
  923.     int pid = getPID(bm);
  924.     sprintf(lj, "/proc/%d/maps", pid);
  925.     fp = fopen(lj, "r");
  926.     if (fp == NULL)
  927.     {
  928.         puts("分析失败");
  929.         return NULL;
  930.     }
  931.     while (!feof(fp))
  932.     {
  933.         fgets(buff,sizeof(buff),fp);//读取一行
  934.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"[stack]"))
  935.         {
  936.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  937.             //这里使用lx是为了能成功读取特别长的地址
  938.             flag=1;
  939.         }
  940.         else
  941.         {
  942.             flag=0;
  943.         }
  944.         if (flag==1)
  945.         {
  946.             i++;
  947.             if (i==1)
  948.             {
  949.                 pNew->next=NULL;
  950.                 pEnd=pNew;
  951.                 pHead=pNew;
  952.             }
  953.             else
  954.             {
  955.                 pNew->next=NULL;
  956.                 pEnd->next=pNew;
  957.                 pEnd=pNew;
  958.             }
  959.             pNew=(PMAPS)malloc(LEN);//分配内存
  960.         }
  961.     }
  962.     free(pNew);//将多余的空间释放
  963.     fclose(fp);//关闭文件指针
  964.     return pHead;
  965. }
  966.  
  967. PMAPS readmaps_other(PACKAGENAME *bm)
  968. {
  969.     PMAPS pHead=NULL;
  970.     PMAPS pNew=NULL;
  971.     PMAPS pEnd=NULL;
  972.     pEnd=pNew=(PMAPS)malloc(LEN);
  973.     FILE *fp;
  974.     int i = 0,flag=1;
  975.     char lj[64], buff[256];
  976.     int pid = getPID(bm);
  977.     sprintf(lj, "/proc/%d/maps", pid);
  978.     fp = fopen(lj, "r");
  979.     if (fp == NULL)
  980.     {
  981.         puts("分析失败");
  982.         return NULL;
  983.     }
  984.     while (!feof(fp))
  985.     {
  986.         fgets(buff,sizeof(buff),fp);//读取一行
  987.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"[anon:thread signal stack]"))
  988.         {
  989.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  990.             //这里使用lx是为了能成功读取特别长的地址
  991.             flag=1;
  992.         }
  993.         else
  994.         {
  995.             flag=0;
  996.         }
  997.         if (flag==1)
  998.         {
  999.             i++;
  1000.             if (i==1)
  1001.             {
  1002.                 pNew->next=NULL;
  1003.                 pEnd=pNew;
  1004.                 pHead=pNew;
  1005.             }
  1006.             else
  1007.             {
  1008.                 pNew->next=NULL;
  1009.                 pEnd->next=pNew;
  1010.                 pEnd=pNew;
  1011.             }
  1012.             pNew=(PMAPS)malloc(LEN);//分配内存
  1013.         }
  1014.     }
  1015.     free(pNew);//将多余的空间释放
  1016.     fclose(fp);//关闭文件指针
  1017.     return pHead;
  1018. }
  1019.  
  1020. PMAPS readmaps_ashmem(PACKAGENAME *bm)
  1021. {
  1022.     PMAPS pHead=NULL;
  1023.     PMAPS pNew=NULL;
  1024.     PMAPS pEnd=NULL;
  1025.     pEnd=pNew=(PMAPS)malloc(LEN);
  1026.     FILE *fp;
  1027.     int i = 0,flag=1;
  1028.     char lj[64], buff[256];
  1029.     int pid = getPID(bm);
  1030.     sprintf(lj, "/proc/%d/maps", pid);
  1031.     fp = fopen(lj, "r");
  1032.     if (fp == NULL)
  1033.     {
  1034.         puts("分析失败");
  1035.         return NULL;
  1036.     }
  1037.     while (!feof(fp))
  1038.     {
  1039.         fgets(buff,sizeof(buff),fp);//读取一行
  1040.         if (strstr(buff, "rw") != NULL && !feof(fp) && strstr(buff,"/dev/ashmem/") && !strstr(buff,"dalvik"))
  1041.         {
  1042.             sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  1043.             //这里使用lx是为了能成功读取特别长的地址
  1044.             flag=1;
  1045.         }
  1046.         else
  1047.         {
  1048.             flag=0;
  1049.         }
  1050.         if (flag==1)
  1051.         {
  1052.             i++;
  1053.             if (i==1)
  1054.             {
  1055.                 pNew->next=NULL;
  1056.                 pEnd=pNew;
  1057.                 pHead=pNew;
  1058.             }
  1059.             else
  1060.             {
  1061.                 pNew->next=NULL;
  1062.                 pEnd->next=pNew;
  1063.                 pEnd=pNew;
  1064.             }
  1065.             pNew=(PMAPS)malloc(LEN);//分配内存
  1066.         }
  1067.     }
  1068.     free(pNew);//将多余的空间释放
  1069.     fclose(fp);//关闭文件指针
  1070.     return pHead;
  1071. }
  1072.  
  1073. PMAPS readmaps_code_app(PACKAGENAME *bm)
  1074. {
  1075. PMAPS pHead=NULL;
  1076. PMAPS pNew=NULL;
  1077. PMAPS pEnd=NULL;
  1078. pEnd=pNew=(PMAPS)malloc(LEN);
  1079. FILE *fp;
  1080. int i = 0,flag=1;
  1081. char lj[64], buff[256];
  1082. int pid = getPID(bm);
  1083. sprintf(lj, "/proc/%d/maps", pid);
  1084. fp = fopen(lj, "r");
  1085. if (fp == NULL)
  1086. {
  1087. puts("分析失败");
  1088. return NULL;
  1089. }
  1090. while (!feof(fp))
  1091. {
  1092. fgets(buff,sizeof(buff),fp);//读取一行
  1093. if (strstr(buff, "r-xp") != NULL && !feof(fp) && strstr(buff,"/data/app/"))
  1094. {
  1095. sscanf(buff, "%lx-%lx", &pNew->addr, &pNew->taddr);
  1096. //这里使用lx是为了能成功读取特别长的地址
  1097. flag=1;
  1098. }
  1099. else
  1100. {
  1101. flag=0;
  1102. }
  1103. if (flag==1)
  1104. {
  1105. i++;
  1106. if (i==1)
  1107. {
  1108. pNew->next=NULL;
  1109. pEnd=pNew;
  1110. pHead=pNew;
  1111. }
  1112. else
  1113. {
  1114. pNew->next=NULL;
  1115. pEnd->next=pNew;
  1116. pEnd=pNew;
  1117. }
  1118. pNew=(PMAPS)malloc(LEN);//分配内存
  1119. }
  1120. }
  1121. free(pNew);//将多余的空间释放
  1122. fclose(fp);//关闭文件指针
  1123. return pHead;
  1124. }
  1125.  
  1126.  
  1127.  
  1128.  
  1129. void Print()
  1130. {
  1131.     PMAPS temp = Res;
  1132.     int i;
  1133.     for (i=0;i<ResCount;i++)
  1134.     {
  1135.         printf("addr:0x%lX,taddr:0x%lX\n", temp->addr, temp->taddr);
  1136.         temp = temp->next;//指向下一个节点
  1137.     }
  1138. }
  1139.  
  1140. void ClearResults()//清空
  1141. {
  1142.     PMAPS pHead=Res;
  1143.     PMAPS pTemp=pHead;
  1144.     int i;
  1145.     for (i=0;i<ResCount;i++)
  1146.     {
  1147.         pTemp=pHead;
  1148.         pHead=pHead->next;
  1149.         free(pTemp);
  1150.     }
  1151. }
  1152.  
  1153. void BaseAddressSearch(PACKAGENAME *bm,char *value,COUNT *gs,TYPE type,ADDRESS BaseAddr)
  1154. {
  1155.     PMAPS pHead=NULL;
  1156.     PMAPS pMap=NULL;
  1157.     switch (MemorySearchRange)
  1158.     {
  1159.         case ALL:
  1160.             pMap=readmaps(bm,ALL);
  1161.             break;
  1162.         case B_BAD:
  1163.             pMap=readmaps(bm,B_BAD);
  1164.             break;
  1165.         case V:
  1166.             pMap = readmaps_v(bm);
  1167.             break;
  1168.         case C_ALLOC:
  1169.             pMap=readmaps(bm,C_ALLOC);
  1170.             break;
  1171.         case C_BSS:
  1172.             pMap=readmaps(bm,C_BSS);
  1173.             break;
  1174.         case C_DATA:
  1175.             pMap=readmaps(bm,C_DATA);
  1176.             break;
  1177.         case C_HEAP:
  1178.             pMap=readmaps(bm,C_HEAP);
  1179.             break;
  1180.         case JAVA_HEAP:
  1181.             pMap=readmaps(bm,JAVA_HEAP);
  1182.             break;
  1183.         case A_ANONMYOUS:
  1184.             pMap=readmaps(bm,A_ANONMYOUS);
  1185.             break;
  1186.         case CODE_SYSTEM:
  1187.             pMap=readmaps(bm,CODE_SYSTEM);
  1188.             break;
  1189.         case STACK:
  1190.             pMap=readmaps(bm,STACK);
  1191.             break;
  1192.         case ASHMEM:
  1193.             pMap=readmaps(bm,ASHMEM);
  1194.             break;
  1195.         case CODE_APP:
  1196. pMap=readmaps_code_app(bm);
  1197. break;
  1198. case OTHER:
  1199. pMap=readmaps_other(bm);
  1200. break;
  1201.         default:
  1202.             printf("\033[32;1mYou Select A NULL Type!\n");
  1203.             break;
  1204.     }
  1205.     if (pMap == NULL)
  1206.     {
  1207.         puts("map error");
  1208.         return (void)0;
  1209.     }
  1210.     switch (type)
  1211.     {
  1212.         case DWORD:
  1213.             pHead=BaseAddressSearch_DWORD(bm,atoi(value),gs,BaseAddr,pMap);
  1214.             break;
  1215.         case FLOAT:
  1216.             pHead=BaseAddressSearch_FLOAT(bm,atof(value),gs,BaseAddr,pMap);
  1217.             break;
  1218.         default:
  1219.             printf("\033[32;1mYou Select A NULL Type!\n");
  1220.             break;
  1221.     }
  1222.     if (pHead == NULL)
  1223.     {
  1224.         puts("search error");
  1225.         return (void)0;
  1226.     }
  1227.     ResCount=*gs;
  1228.     Res=pHead;//Res指针指向链表
  1229. }
  1230.  
  1231. PMAPS BaseAddressSearch_DWORD(PACKAGENAME *bm,int value,COUNT *gs,ADDRESS BaseAddr,PMAPS pMap)
  1232. {
  1233.     *gs=0;
  1234.     //printf("BaseAddress:%lX\n",BaseAddr);
  1235.     pid_t pid=getPID(bm);
  1236.     if (pid == 0)
  1237.     {
  1238.         puts("can not get pid");
  1239.         return 0;
  1240.     }
  1241.     PMAPS e,n;
  1242.     e=n=(PMAPS)malloc(LEN);
  1243.     PMAPS pBuff=n;
  1244.     int iCount=0;
  1245.     long int c,ADDR;
  1246.     int handle;
  1247.     char lj[64];
  1248.     sprintf(lj, "/proc/%d/mem", pid);
  1249.     handle = open(lj, O_RDWR);//打开mem文件
  1250.     lseek(handle, 0, SEEK_SET);
  1251.     void *BUF[8];
  1252.     PMAPS pTemp=pMap;
  1253.     while (pTemp != NULL)
  1254.     {
  1255.         c=(pTemp->taddr-pTemp->addr)/4096;
  1256.         for (int j=0;j<c;j++)
  1257.         {
  1258.             ADDR=pTemp->addr+j*4096+BaseAddr;
  1259.             pread64(handle,BUF,8,ADDR);
  1260.             if (*(int*)&BUF[0] == value)
  1261.             {
  1262.                 iCount++;
  1263.                 *gs+=1;
  1264.                 ResCount+=1;
  1265.                 n->addr=ADDR;
  1266.                 //printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
  1267.                 if (iCount==1)
  1268.                 {
  1269.                     n->next=NULL;
  1270.                     e=n;
  1271.                     pBuff=n;
  1272.                 }
  1273.                 else
  1274.                 {
  1275.                     n->next=NULL;
  1276.                     e->next=n;
  1277.                     e=n;
  1278.                 }
  1279.                 n=(PMAPS)malloc(LEN);
  1280.             }
  1281.         }
  1282.         pTemp=pTemp->next;
  1283.     }
  1284.     close(handle);
  1285.     return pBuff;
  1286. }
  1287.  
  1288. PMAPS BaseAddressSearch_FLOAT(PACKAGENAME *bm,float value,COUNT *gs,ADDRESS BaseAddr,PMAPS pMap)
  1289. {
  1290.     *gs=0;
  1291.     pid_t pid=getPID(bm);
  1292.     if (pid == 0)
  1293.     {
  1294.         puts("can not get pid");
  1295.         return 0;
  1296.     }
  1297.     PMAPS e,n;
  1298.     e=n=(PMAPS)malloc(LEN);
  1299.     PMAPS pBuff=n;
  1300.     long int c,ADDR;
  1301.     int handle;
  1302.     int iCount=0;
  1303.     char lj[64];
  1304.     sprintf(lj, "/proc/%d/mem", pid);
  1305.     handle = open(lj, O_RDWR);//打开mem文件
  1306.     lseek(handle, 0, SEEK_SET);
  1307.     void *BUF[8];
  1308.     PMAPS pTemp=pMap;
  1309.     while (pTemp != NULL)
  1310.     {
  1311.         c=(pTemp->taddr-pTemp->addr)/4096;
  1312.         for (int j=0;j<c;j++)
  1313.         {
  1314.             ADDR=pTemp->addr+j*4096+BaseAddr;
  1315.             pread64(handle,BUF,8,ADDR);
  1316.             if (*(float*)&BUF[0] == value)
  1317.             {
  1318.                 iCount++;
  1319.                 *gs+=1;
  1320.                 ResCount+=1;
  1321.                 n->addr=ADDR;
  1322.                 //printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
  1323.                 if (iCount==1)
  1324.                 {
  1325.                     n->next=NULL;
  1326.                     e=n;
  1327.                     pBuff=n;
  1328.                 }
  1329.                 else
  1330.                 {
  1331.                     n->next=NULL;
  1332.                     e->next=n;
  1333.                     e=n;
  1334.                 }
  1335.                 n=(PMAPS)malloc(LEN);
  1336.             }
  1337.         }
  1338.         pTemp=pTemp->next;
  1339.     }
  1340.     close(handle);
  1341.     return pBuff;
  1342. }
  1343.  
  1344. void RangeMemorySearch(PACKAGENAME *bm,char *from_value,char *to_value,COUNT *gs,TYPE type)//范围搜索
  1345. {
  1346.     PMAPS pHead=NULL;
  1347.     PMAPS pMap=NULL;
  1348.     switch (MemorySearchRange)
  1349.     {
  1350.         case ALL:
  1351.             pMap=readmaps(bm,ALL);
  1352.             break;
  1353.         case B_BAD:
  1354.             pMap=readmaps(bm,B_BAD);
  1355.             break;
  1356.         case V:
  1357.             pMap = readmaps_v(bm);
  1358.             break;
  1359.         case C_ALLOC:
  1360.             pMap=readmaps(bm,C_ALLOC);
  1361.             break;
  1362.         case C_BSS:
  1363.             pMap=readmaps(bm,C_BSS);
  1364.             break;
  1365.         case C_DATA:
  1366.             pMap=readmaps(bm,C_DATA);
  1367.             break;
  1368.         case C_HEAP:
  1369.             pMap=readmaps(bm,C_HEAP);
  1370.             break;
  1371.         case JAVA_HEAP:
  1372.             pMap=readmaps(bm,JAVA_HEAP);
  1373.             break;
  1374.         case A_ANONMYOUS:
  1375.             pMap=readmaps(bm,A_ANONMYOUS);
  1376.             break;
  1377.         case CODE_SYSTEM:
  1378.             pMap=readmaps(bm,CODE_SYSTEM);
  1379.             break;
  1380.         case STACK:
  1381.             pMap=readmaps(bm,STACK);
  1382.             break;
  1383.         case ASHMEM:
  1384.             pMap=readmaps(bm,ASHMEM);
  1385.             break;
  1386.         case CODE_APP:
  1387. pMap=readmaps_code_app(bm);
  1388. break;
  1389. case OTHER:
  1390. pMap=readmaps_other(bm);
  1391. break;
  1392.         default:
  1393.             printf("\033[32;1mYou Select A NULL Type!\n");
  1394.             break;
  1395.     }
  1396.     if (pMap == NULL)
  1397.     {
  1398.         puts("map error");
  1399.         return (void)0;
  1400.     }
  1401.     switch (type)
  1402.     {
  1403.         case DWORD:
  1404.             if (atoi(from_value) > atoi(to_value))
  1405.                 pHead=RangeMemorySearch_DWORD(bm,atoi(to_value),atoi(from_value),gs,pMap);
  1406.             else
  1407.                 pHead=RangeMemorySearch_DWORD(bm,atoi(from_value),atoi(to_value),gs,pMap);
  1408.             break;
  1409.         case FLOAT:
  1410.             if (atof(from_value) > atof(to_value))
  1411.                 pHead=RangeMemorySearch_FLOAT(bm,atof(to_value),atof(from_value),gs,pMap);
  1412.             else
  1413.                 pHead=RangeMemorySearch_FLOAT(bm,atof(from_value),atof(to_value),gs,pMap);
  1414.             break;
  1415.         default:
  1416.             printf("\033[32;1mYou Select A NULL Type!\n");
  1417.             break;
  1418.     }
  1419.     if (pHead == NULL)
  1420.     {
  1421.         puts("RangeSearch Error");
  1422.         return (void)0;
  1423.     }
  1424.     ResCount=*gs;
  1425.     Res=pHead;//Res指针指向链表
  1426. }
  1427.  
  1428. PMAPS RangeMemorySearch_DWORD(PACKAGENAME *bm,int from_value,int to_value,COUNT *gs,PMAPS pMap)//DWORD
  1429. {
  1430.     pid_t pid=getPID(bm);
  1431.     if (pid == 0)
  1432.     {
  1433.         puts("can not get pid");
  1434.         return NULL;
  1435.     }
  1436.     *gs=0;
  1437.     PMAPS pTemp=NULL;
  1438.     pTemp=pMap;
  1439.     PMAPS n,e;
  1440.     e=n=(PMAPS)malloc(LEN);
  1441.     PMAPS pBuff;
  1442.     pBuff=n;
  1443.     int handle;//句柄
  1444.     int iCount=0;//链表长度
  1445.     int c;
  1446.     char lj[64];//路径
  1447.     int buff[1024]={0};//缓冲区
  1448.     memset(buff,0,4);
  1449.     sprintf(lj, "/proc/%d/mem", pid);
  1450.     handle = open(lj, O_RDWR);//打开mem文件
  1451.     lseek(handle, 0, SEEK_SET);
  1452.     while (pTemp != NULL)//读取maps里面的地址
  1453.     {
  1454.         c=(pTemp->taddr-pTemp->addr)/4096;
  1455.         for (int j=0;j<c;j++)
  1456.         {
  1457.             pread64(handle,buff,0x1000,pTemp->addr+j*4096);
  1458.             for (int i=0;i<1024;i++)
  1459.             {
  1460.                 if (buff[i] >= from_value && buff[i] <= to_value)//判断值是否在这两者之间
  1461.                 {
  1462.                     iCount++;
  1463.                     *gs+=1;
  1464.                     ResCount+=1;
  1465.                     n->addr=(pTemp->addr)+(j*4096)+(i*4);
  1466.                     if (iCount==1)
  1467.                     {
  1468.                         n->next=NULL;
  1469.                         e=n;
  1470.                         pBuff=n;
  1471.                     }
  1472.                     else
  1473.                     {
  1474.                         n->next=NULL;
  1475.                         e->next=n;
  1476.                         e=n;
  1477.                     }
  1478.                     n=(PMAPS)malloc(LEN);
  1479.                 }
  1480.             }
  1481.         }
  1482.         pTemp = pTemp->next;
  1483.     }
  1484.     free(n);
  1485.     close(handle);
  1486.     return pBuff;
  1487. }
  1488.  
  1489. PMAPS RangeMemorySearch_FLOAT(PACKAGENAME *bm,float from_value,float to_value,COUNT *gs,PMAPS pMap)//FLOAT
  1490. {
  1491.     pid_t pid=getPID(bm);
  1492.     if (pid == 0)
  1493.     {
  1494.         puts("can not get pid");
  1495.         return NULL;
  1496.     }
  1497.     *gs=0;
  1498.     PMAPS pTemp=NULL;
  1499.     pTemp=pMap;
  1500.     PMAPS n,e;
  1501.     e=n=(PMAPS)malloc(LEN);
  1502.     PMAPS pBuff;
  1503.     pBuff=n;
  1504.     int handle;//句柄
  1505.     int iCount=0;//链表长度
  1506.     int c;
  1507.     char lj[64];//路径
  1508.     float buff[1024]={0};//缓冲区
  1509.     sprintf(lj, "/proc/%d/mem", pid);
  1510.     handle = open(lj, O_RDWR);//打开mem文件
  1511.     lseek(handle, 0, SEEK_SET);
  1512.     while (pTemp->next != NULL)
  1513.     {
  1514.         c=(pTemp->taddr-pTemp->addr)/4096;
  1515.         for (int j=0;j<c;j+=1)
  1516.         {
  1517.             pread64(handle,buff,0x1000,pTemp->addr+(j*4096));
  1518.             for (int i=0;i<1024;i+=1)
  1519.             {
  1520.                 if (buff[i] >= from_value && buff[i] <= to_value)//判断。。。
  1521.                 {
  1522.                     iCount++;
  1523.                     *gs+=1;
  1524.                     ResCount+=1;
  1525.                     n->addr=(pTemp->addr)+(j*4096)+(i*4);
  1526.                     if (iCount==1)
  1527.                     {
  1528.                         n->next=NULL;
  1529.                         e=n;
  1530.                         pBuff=n;
  1531.                     }
  1532.                     else
  1533.                     {
  1534.                         n->next=NULL;
  1535.                         e->next=n;
  1536.                         e=n;
  1537.                     }
  1538.                     n=(PMAPS)malloc(LEN);
  1539.                 }
  1540.                 //printf("buff[%d]=%f\n",l,buff[l]);
  1541.                 //usleep(1);
  1542.             }
  1543.             //memset(buff,0,4);
  1544.         }
  1545.         pTemp = pTemp->next;
  1546.     }
  1547.     free(n);
  1548.     close(handle);
  1549.     return pBuff;
  1550. }
  1551.  
  1552. void MemorySearch(PACKAGENAME *bm,char *value,int *gs,TYPE type)
  1553. {
  1554.     PMAPS pHead=NULL;
  1555.     PMAPS pMap=NULL;
  1556.     switch (MemorySearchRange)
  1557.     {
  1558.         case ALL:
  1559.             pMap=readmaps(bm,ALL);
  1560.             break;
  1561.         case B_BAD:
  1562.             pMap=readmaps(bm,B_BAD);
  1563.             break;
  1564.         case V:
  1565.             pMap = readmaps_v(bm);
  1566.             break;
  1567.         case C_ALLOC:
  1568.             pMap=readmaps(bm,C_ALLOC);
  1569.             break;
  1570.         case C_BSS:
  1571.             pMap=readmaps(bm,C_BSS);
  1572.             break;
  1573.         case C_DATA:
  1574.             pMap=readmaps(bm,C_DATA);
  1575.             break;
  1576.         case C_HEAP:
  1577.             pMap=readmaps(bm,C_HEAP);
  1578.             break;
  1579.         case JAVA_HEAP:
  1580.             pMap=readmaps(bm,JAVA_HEAP);
  1581.             break;
  1582.         case A_ANONMYOUS:
  1583.             pMap=readmaps(bm,A_ANONMYOUS);
  1584.             break;
  1585.         case CODE_SYSTEM:
  1586.             pMap=readmaps(bm,CODE_SYSTEM);
  1587.             break;
  1588.         case STACK:
  1589.             pMap=readmaps(bm,STACK);
  1590.             break;
  1591.         case ASHMEM:
  1592.             pMap=readmaps(bm,ASHMEM);
  1593.             break;
  1594.         case CODE_APP:
  1595. pMap=readmaps_code_app(bm);
  1596. break;
  1597. case OTHER:
  1598. pMap=readmaps_other(bm);
  1599. break;
  1600.         default:
  1601.             printf("\033[32;1mYou Select A NULL Type!\n");
  1602.             break;
  1603.     }
  1604.     if (pMap == NULL)
  1605.     {
  1606.         puts("map error");
  1607.         return (void)0;
  1608.     }
  1609.     switch (type)
  1610.     {
  1611.         case DWORD:
  1612.             pHead=MemorySearch_DWORD(bm,atoi(value),gs,pMap);
  1613.             break;
  1614.         case FLOAT:
  1615.             pHead=MemorySearch_FLOAT(bm,atof(value),gs,pMap);
  1616.             break;
  1617.         default:
  1618.             printf("\033[32;1mYou Select A NULL Type!\n");
  1619.             break;
  1620.     }
  1621.     if (pHead == NULL)
  1622.     {
  1623.         puts("search error");
  1624.         return (void)0;
  1625.     }
  1626.     ResCount=*gs;
  1627.     Res=pHead;//Res指针指向链表
  1628. }
  1629.  
  1630. PMAPS MemorySearch_DWORD(PACKAGENAME *bm,int value,COUNT *gs,PMAPS pMap)
  1631. {
  1632.     pid_t pid=getPID(bm);
  1633.     if (pid == 0)
  1634.     {
  1635.         puts("can not get pid");
  1636.         return NULL;
  1637.     }
  1638.     *gs=0;
  1639.     PMAPS pTemp=NULL;
  1640.     pTemp=pMap;
  1641.     PMAPS n,e;
  1642.     e=n=(PMAPS)malloc(LEN);
  1643.     PMAPS pBuff;
  1644.     pBuff=n;
  1645.     int handle;//句柄
  1646.     int iCount=0;//链表长度
  1647.     int c;
  1648.     char lj[64];//路径
  1649.     int buff[1024]={0};//缓冲区
  1650.     memset(buff,0,4);
  1651.     sprintf(lj, "/proc/%d/mem", pid);
  1652.     handle = open(lj, O_RDWR);//打开mem文件
  1653.     lseek(handle, 0, SEEK_SET);
  1654.     while (pTemp != NULL)//读取maps里面的地址
  1655.     {
  1656.         c=(pTemp->taddr-pTemp->addr)/4096;
  1657.         for (int j=0;j<c;j++)
  1658.         {
  1659.             pread64(handle,buff,0x1000,pTemp->addr+j*4096);
  1660.             for (int i=0;i<1024;i++)
  1661.             {
  1662.                 if (buff[i]==value)
  1663.                 {
  1664.                     iCount++;
  1665.                     *gs+=1;
  1666.                     ResCount+=1;
  1667.                     n->addr=(pTemp->addr)+(j*4096)+(i*4);
  1668.                     //printf("addr:%lx,val:%d,buff=%d\n",n->addr,value,buff[i]);
  1669.                     if (iCount==1)
  1670.                     {
  1671.                         n->next=NULL;
  1672.                         e=n;
  1673.                         pBuff=n;
  1674.                     }
  1675.                     else
  1676.                     {
  1677.                         n->next=NULL;
  1678.                         e->next=n;
  1679.                         e=n;
  1680.                     }
  1681.                     n=(PMAPS)malloc(LEN);
  1682.                 }
  1683.             }
  1684.         }
  1685.         pTemp = pTemp->next;
  1686.     }
  1687.     free(n);
  1688.     close(handle);
  1689.     return pBuff;
  1690. }
  1691.  
  1692. PMAPS MemorySearch_FLOAT(PACKAGENAME *bm,float value,COUNT *gs,PMAPS pMap)
  1693. {
  1694.     pid_t pid=getPID(bm);
  1695.     if (pid == 0)
  1696.     {
  1697.         puts("can not get pid");
  1698.         return NULL;
  1699.     }
  1700.     *gs=0;
  1701.     PMAPS pTemp=NULL;
  1702.     pTemp=pMap;
  1703.     PMAPS n,e;
  1704.     e=n=(PMAPS)malloc(LEN);
  1705.     PMAPS pBuff;
  1706.     pBuff=n;
  1707.     int handle;//句柄
  1708.     int iCount=0;//链表长度
  1709.     int c;
  1710.     char lj[64];//路径
  1711.     float buff[1024]={0};//缓冲区
  1712.     sprintf(lj, "/proc/%d/mem", pid);
  1713.     handle = open(lj, O_RDWR);//打开mem文件
  1714.     lseek(handle, 0, SEEK_SET);
  1715.     while (pTemp->next != NULL)
  1716.     {
  1717.         c=(pTemp->taddr-pTemp->addr)/4096;
  1718.         for (int j=0;j<c;j+=1)
  1719.         {
  1720.             pread64(handle,buff,0x1000,pTemp->addr+(j*4096));
  1721.             for (int i=0;i<1024;i+=1)
  1722.             {
  1723.                 if (buff[i]==value)
  1724.                 {
  1725.                     iCount++;
  1726.                     *gs+=1;
  1727.                     ResCount+=1;
  1728.                     n->addr=(pTemp->addr)+(j*4096)+(i*4);
  1729.                     if (iCount==1)
  1730.                     {
  1731.                         n->next=NULL;
  1732.                         e=n;
  1733.                         pBuff=n;
  1734.                     }
  1735.                     else
  1736.                     {
  1737.                         n->next=NULL;
  1738.                         e->next=n;
  1739.                         e=n;
  1740.                     }
  1741.                     n=(PMAPS)malloc(LEN);
  1742.                 }
  1743.                 //printf("buff[%d]=%f\n",l,buff[l]);
  1744.                 //usleep(1);
  1745.             }
  1746.             //memset(buff,0,4);
  1747.         }
  1748.         pTemp = pTemp->next;
  1749.     }
  1750.     free(n);
  1751.     close(handle);
  1752.     return pBuff;
  1753. }
  1754.  
  1755. void MemoryOffset(PACKAGENAME *bm,char *value,OFFSET offset,COUNT *gs,TYPE type)
  1756. {
  1757.     PMAPS pHead=NULL;
  1758.     switch (type)
  1759.     {
  1760.         case DWORD:
  1761.             pHead=MemoryOffset_DWORD(bm,atoi(value),offset,Res,gs);
  1762.             break;
  1763.         case FLOAT:
  1764.             pHead=MemoryOffset_FLOAT(bm,atof(value),offset,Res,gs);
  1765.             break;
  1766.         default:
  1767.             printf("\033[32;1mYou Select A NULL Type!\n");
  1768.             break;
  1769.     }
  1770.     if (pHead == NULL)
  1771.     {
  1772.         puts("offset error");
  1773.         return (void)0;
  1774.     }
  1775.     ResCount=*gs;//全局个数
  1776.     ClearResults();//清空存储的数据(释放空间)
  1777.     Res=pHead;//指向新搜索到的空间
  1778. }
  1779.  
  1780. PMAPS MemoryOffset_DWORD(PACKAGENAME *bm,int value,OFFSET offset,PMAPS pBuff,COUNT *gs)//搜索偏移
  1781. {
  1782.     pid_t pid=getPID(bm);
  1783.     if (pid == 0)
  1784.     {
  1785.         puts("can not get pid");
  1786.         return 0;
  1787.     }
  1788.     *gs=0;//初始个数为0
  1789.     PMAPS pEnd=NULL;
  1790.     PMAPS pNew=NULL;
  1791.     PMAPS pTemp=pBuff;
  1792.     PMAPS BUFF=NULL;
  1793.     pEnd=pNew=(PMAPS)malloc(LEN);
  1794.     BUFF=pNew;
  1795.     int iCount=0,handle;//个数与句柄
  1796.     char lj[64];//路径
  1797.     long int all;//总和
  1798.     int *buf=(int *)malloc(sizeof(int));//缓冲区
  1799.     int jg;
  1800.     sprintf(lj,"/proc/%d/mem",pid);
  1801.     handle=open(lj,O_RDWR);
  1802.     lseek(handle,0,SEEK_SET);
  1803.     while (pTemp != NULL)
  1804.     {
  1805.         all=pTemp->addr+offset;
  1806.         pread64(handle,buf,4,all);
  1807.         jg=*buf;
  1808.         if (jg == value)
  1809.         {
  1810.             iCount++;
  1811.             *gs+=1;
  1812.             pNew->addr=pTemp->addr;
  1813.             if (iCount == 1)
  1814.             {
  1815.                 pNew->next=NULL;
  1816.                 pEnd=pNew;
  1817.                 BUFF=pNew;
  1818.             }
  1819.             else
  1820.             {
  1821.                 pNew->next=NULL;
  1822.                 pEnd->next=pNew;
  1823.                 pEnd=pNew;
  1824.             }
  1825.             pNew=(PMAPS)malloc(LEN);
  1826.             if (ResCount==1)
  1827.             {
  1828.                 free(pNew);
  1829.                 close(handle);
  1830.                 return BUFF;
  1831.             }
  1832.         }
  1833.         /*else
  1834.         {
  1835.             printf("jg:%d,value:%d\n",jg,value);
  1836.         }*/
  1837.         pTemp=pTemp->next;//指向下一个节点读取数据
  1838.     }
  1839.     free(pNew);
  1840.     close(handle);
  1841.     return BUFF;
  1842. }
  1843.  
  1844. PMAPS MemoryOffset_FLOAT(PACKAGENAME *bm,float value,OFFSET offset,PMAPS pBuff,COUNT *gs)//搜索偏移
  1845. {
  1846.     pid_t pid=getPID(bm);
  1847.     if (pid == 0)
  1848.     {
  1849.         puts("can not get pid");
  1850.         return 0;
  1851.     }
  1852.     *gs=0;//初始个数为0
  1853.     PMAPS pEnd=NULL;
  1854.     PMAPS pNew=NULL;
  1855.     PMAPS pTemp=pBuff;
  1856.     PMAPS BUFF=NULL;
  1857.     pEnd=pNew=(PMAPS)malloc(LEN);
  1858.     BUFF=pNew;
  1859.     int iCount=0,handle;//个数与句柄
  1860.     char lj[64];//路径
  1861.     long int all;//总和
  1862.     float *buf=(float *)malloc(sizeof(float));//缓冲区
  1863.     //int buf[16];  //出现异常使用
  1864.     float jg;
  1865.     sprintf(lj,"/proc/%d/mem",pid);
  1866.     handle=open(lj,O_RDWR);
  1867.     lseek(handle,0,SEEK_SET);
  1868.     while (pTemp != NULL)
  1869.     {
  1870.         all=pTemp->addr+offset;//偏移后的地址
  1871.         pread64(handle,buf,4,all);
  1872.         jg=*buf;
  1873.         if (jg == value)
  1874.         {
  1875.             iCount++;
  1876.             *gs+=1;
  1877.             //printf("偏移成功,addr:%lx\n",all);
  1878.             pNew->addr=pTemp->addr;
  1879.             if (iCount == 1)
  1880.             {
  1881.                 pNew->next=NULL;
  1882.                 pEnd=pNew;
  1883.                 BUFF=pNew;
  1884.             }
  1885.             else
  1886.             {
  1887.                 pNew->next=NULL;
  1888.                 pEnd->next=pNew;
  1889.                 pEnd=pNew;
  1890.             }
  1891.             pNew=(PMAPS)malloc(LEN);
  1892.             if (ResCount==1)
  1893.             {
  1894.                 free(pNew);
  1895.                 close(handle);
  1896.                 return BUFF;
  1897.             }
  1898.         }
  1899.         /*else
  1900.         {
  1901.             printf("jg:%e,value:%e\n",jg,value);
  1902.         }*/
  1903.         pTemp=pTemp->next;//指向下一个节点读取数据
  1904.     }
  1905.     free(pNew);
  1906.     close(handle);
  1907.     return BUFF;
  1908. }
  1909.  
  1910. void RangeMemoryOffset(PACKAGENAME *bm,char *from_value,char *to_value,OFFSET offset,COUNT *gs,TYPE type)//范围偏移
  1911. {
  1912.     PMAPS pHead=NULL;
  1913.     switch (type)
  1914.     {
  1915.         case DWORD:
  1916.             if (atoi(from_value) > atoi(to_value))
  1917.                 pHead=RangeMemoryOffset_DWORD(bm,atoi(to_value),atoi(from_value),offset,Res,gs);
  1918.             else
  1919.                 pHead=RangeMemoryOffset_DWORD(bm,atoi(from_value),atoi(to_value),offset,Res,gs);
  1920.             break;
  1921.         case FLOAT:
  1922.             if (atof(from_value) > atof(to_value))
  1923.                 pHead=RangeMemoryOffset_FLOAT(bm,atof(to_value),atof(from_value),offset,Res,gs);
  1924.             else
  1925.                 pHead=RangeMemoryOffset_FLOAT(bm,atof(from_value),atof(to_value),offset,Res,gs);
  1926.             break;
  1927.         default:
  1928.             printf("\033[32;1mYou Select A NULL Type!\n");
  1929.             break;
  1930.     }
  1931.     if (pHead == NULL)
  1932.     {
  1933.         puts("RangeOffset error");
  1934.         return (void)0;
  1935.     }
  1936.     ResCount=*gs;//全局个数
  1937.     ClearResults();//清空存储的数据(释放空间)
  1938.     Res=pHead;//指向新搜索到的空间
  1939. }
  1940.  
  1941. PMAPS RangeMemoryOffset_DWORD(PACKAGENAME *bm,int from_value,int to_value,OFFSET offset,PMAPS pBuff,COUNT *gs)//搜索偏移DWORD
  1942. {
  1943.     pid_t pid=getPID(bm);
  1944.     if (pid == 0)
  1945.     {
  1946.         puts("can not get pid");
  1947.         return 0;
  1948.     }
  1949.     *gs=0;//初始个数为0
  1950.     PMAPS pEnd=NULL;
  1951.     PMAPS pNew=NULL;
  1952.     PMAPS pTemp=pBuff;
  1953.     PMAPS BUFF=NULL;
  1954.     pEnd=pNew=(PMAPS)malloc(LEN);
  1955.     BUFF=pNew;
  1956.     int iCount=0,handle;//个数与句柄
  1957.     char lj[64];//路径
  1958.     long int all;//总和
  1959.     int *buf=(int *)malloc(sizeof(int));//缓冲区
  1960.     int jg;
  1961.     sprintf(lj,"/proc/%d/mem",pid);
  1962.     handle=open(lj,O_RDWR);
  1963.     lseek(handle,0,SEEK_SET);
  1964.     while (pTemp != NULL)
  1965.     {
  1966.         all=pTemp->addr+offset;
  1967.         pread64(handle,buf,4,all);
  1968.         jg=*buf;
  1969.         if (jg >= from_value && jg <= to_value)
  1970.         {
  1971.             iCount++;
  1972.             *gs+=1;
  1973.             pNew->addr=pTemp->addr;
  1974.             if (iCount == 1)
  1975.             {
  1976.                 pNew->next=NULL;
  1977.                 pEnd=pNew;
  1978.                 BUFF=pNew;
  1979.             }
  1980.             else
  1981.             {
  1982.                 pNew->next=NULL;
  1983.                 pEnd->next=pNew;
  1984.                 pEnd=pNew;
  1985.             }
  1986.             pNew=(PMAPS)malloc(LEN);
  1987.             if (ResCount==1)
  1988.             {
  1989.                 free(pNew);
  1990.                 close(handle);
  1991.                 return BUFF;
  1992.             }
  1993.         }
  1994.         /*else
  1995.         {
  1996.             printf("jg:%d,value:%d\n",jg,value);
  1997.         }*/
  1998.         pTemp=pTemp->next;//指向下一个节点读取数据
  1999.     }
  2000.     free(pNew);
  2001.     close(handle);
  2002.     return BUFF;
  2003. }
  2004.  
  2005. PMAPS RangeMemoryOffset_FLOAT(PACKAGENAME *bm,float from_value,float to_value,OFFSET offset,PMAPS pBuff,COUNT *gs)//搜索偏移FLOAT
  2006. {
  2007.     pid_t pid=getPID(bm);
  2008.     if (pid == 0)
  2009.     {
  2010.         puts("can not get pid");
  2011.         return 0;
  2012.     }
  2013.     *gs=0;//初始个数为0
  2014.     PMAPS pEnd=NULL;
  2015.     PMAPS pNew=NULL;
  2016.     PMAPS pTemp=pBuff;
  2017.     PMAPS BUFF=NULL;
  2018.     pEnd=pNew=(PMAPS)malloc(LEN);
  2019.     BUFF=pNew;
  2020.     int iCount=0,handle;//个数与句柄
  2021.     char lj[64];//路径
  2022.     long int all;//总和
  2023.     float *buf=(float *)malloc(sizeof(float));//缓冲区
  2024.     //int buf[16];  //出现异常使用
  2025.     float jg;
  2026.     sprintf(lj,"/proc/%d/mem",pid);
  2027.     handle=open(lj,O_RDWR);
  2028.     lseek(handle,0,SEEK_SET);
  2029.     while (pTemp != NULL)
  2030.     {
  2031.         all=pTemp->addr+offset;//偏移后的地址
  2032.         pread64(handle,buf,4,all);
  2033.         jg=*buf;
  2034.         if (jg >= from_value && jg <= to_value)
  2035.         {
  2036.             iCount++;
  2037.             *gs+=1;
  2038.             //printf("偏移成功,addr:%lx\n",all);
  2039.             pNew->addr=pTemp->addr;
  2040.             if (iCount == 1)
  2041.             {
  2042.                 pNew->next=NULL;
  2043.                 pEnd=pNew;
  2044.                 BUFF=pNew;
  2045.             }
  2046.             else
  2047.             {
  2048.                 pNew->next=NULL;
  2049.                 pEnd->next=pNew;
  2050.                 pEnd=pNew;
  2051.             }
  2052.             pNew=(PMAPS)malloc(LEN);
  2053.             if (ResCount==1)
  2054.             {
  2055.                 free(pNew);
  2056.                 close(handle);
  2057.                 return BUFF;
  2058.             }
  2059.         }
  2060.         /*else
  2061.         {
  2062.             printf("jg:%e,value:%e\n",jg,value);
  2063.         }*/
  2064.         pTemp=pTemp->next;//指向下一个节点读取数据
  2065.     }
  2066.     free(pNew);
  2067.     close(handle);
  2068.     return BUFF;
  2069. }
  2070.  
  2071. void MemoryWrite(PACKAGENAME *bm,char *value,OFFSET offset,TYPE type)
  2072. {
  2073.     switch (type)
  2074.     {
  2075.         case DWORD:
  2076.             MemoryWrite_DWORD(bm,atoi(value),Res,offset);
  2077.             break;
  2078.         case FLOAT:
  2079.             MemoryWrite_FLOAT(bm,atof(value),Res,offset);
  2080.             break;
  2081.         default:
  2082.             printf("\033[32;1mYou Select A NULL Type!\n");
  2083.             break;
  2084.     }
  2085.     //ClearResults();//清空list
  2086. }
  2087.  
  2088. int MemoryWrite_DWORD(PACKAGENAME *bm,int value,PMAPS pBuff,OFFSET offset)
  2089. {
  2090.     pid_t pid=getPID(bm);
  2091.     if (pid == 0)
  2092.     {
  2093.         puts("can not get pid");
  2094.         return 0;
  2095.     }
  2096.     PMAPS pTemp=NULL;
  2097.     char lj[64];
  2098.     int handle;
  2099.     pTemp=pBuff;
  2100.     sprintf(lj,"/proc/%d/mem",pid);
  2101.     handle=open(lj,O_RDWR);
  2102.     lseek(handle,0,SEEK_SET);
  2103.     int i;
  2104.     for (i=0;i<ResCount;i++)
  2105.     {
  2106.         pwrite64(handle,&value,4,pTemp->addr+offset);
  2107.         if (pTemp->next != NULL)
  2108.             pTemp=pTemp->next;
  2109.     }
  2110.     close(handle);
  2111.     return 0;
  2112. }
  2113.  
  2114. int MemoryWrite_FLOAT(PACKAGENAME *bm,float value,PMAPS pBuff,OFFSET offset)
  2115. {
  2116.     pid_t pid=getPID(bm);
  2117.     if (pid == 0)
  2118.     {
  2119.         puts("can not get pid");
  2120.         return 0;
  2121.     }
  2122.     PMAPS pTemp=NULL;
  2123.     char lj[64];
  2124.     int handle;
  2125.     pTemp=pBuff;
  2126.     sprintf(lj,"/proc/%d/mem",pid);
  2127.     handle=open(lj,O_RDWR);
  2128.     lseek(handle,0,SEEK_SET);
  2129.     int i;
  2130.     for (i=0;i<ResCount;i++)
  2131.     {
  2132.         pwrite64(handle,&value,4,pTemp->addr+offset);
  2133.         if (pTemp->next != NULL)
  2134.             pTemp=pTemp->next;
  2135.     }
  2136.     close(handle);
  2137.     return 0;
  2138. }
  2139.  
  2140. void *SearchAddress(PACKAGENAME *bm,ADDRESS addr)//返回一个void指针,可以自行转换类型
  2141. {
  2142.     pid_t pid=getPID(bm);
  2143.     if (pid == 0)
  2144.     {
  2145.         puts("can not get pid");
  2146.         return 0;
  2147.     }
  2148.     char lj[64];
  2149.     int handle;
  2150.     void *buf=malloc(8);
  2151.     sprintf(lj,"/proc/%d/mem",pid);
  2152.     handle=open(lj,O_RDWR);
  2153.     lseek(handle,0,SEEK_SET);
  2154.     pread64(handle,buf,8,addr);
  2155.     close(handle);
  2156.     return buf;
  2157. }
  2158.  
  2159. int WriteAddress(PACKAGENAME *bm,ADDRESS addr,void *value,TYPE type)
  2160. {
  2161.     pid_t pid=getPID(bm);
  2162.     if (pid == 0)
  2163.     {
  2164.         puts("can not get pid");
  2165.         return 0;
  2166.     }
  2167.     char lj[64];
  2168.     int handle;
  2169.     sprintf(lj,"/proc/%d/mem",pid);
  2170.     handle=open(lj,O_RDWR);
  2171.     lseek(handle,0,SEEK_SET);
  2172.     switch (type)
  2173.     {
  2174.         case DWORD:
  2175.             pwrite64(handle,(int*)value,4,addr);
  2176.             break;
  2177.         case FLOAT:
  2178.             pwrite64(handle,(float*)value,4,addr);
  2179.             break;
  2180.         default:
  2181.             printf("\033[32;1mYou Select A NULL Type!\n");
  2182.             break;
  2183.     }
  2184.     close(handle);
  2185.     return 0;
  2186. }
  2187.  
  2188. int isapkinstalled(PACKAGENAME *bm)
  2189. {
  2190.     char LJ[128];
  2191.     sprintf(LJ,"/data/data/%s/",bm);
  2192.     DIR *dir;
  2193.     dir=opendir(LJ);
  2194.     if (dir == NULL)
  2195.     {
  2196.         return 0;
  2197.     }
  2198.     else
  2199.     {
  2200.         return 1;
  2201.     }
  2202. }
  2203.  
  2204. int isapkrunning(PACKAGENAME *bm)
  2205. {
  2206.     DIR *dir=NULL;
  2207.     struct dirent *ptr=NULL;
  2208.     FILE *fp=NULL;
  2209.     char filepath[50];          // 大小随意，能装下cmdline文件的路径即可
  2210.     char filetext[128];         // 大小随意，能装下要识别的命令行文本即可
  2211.     dir = opendir("/proc/");        // 打开路径
  2212.     if (dir != NULL)
  2213.     {
  2214.         while ((ptr = readdir(dir)) != NULL)    // 循环读取路径下的每一个文件/文件夹
  2215.         {
  2216.             // 如果读取到的是"."或者".."则跳过，读取到的不是文件夹名字也跳过
  2217.             if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
  2218.                 continue;
  2219.             if (ptr->d_type != DT_DIR)
  2220.                 continue;
  2221.             sprintf(filepath, "/proc/%s/cmdline", ptr->d_name); // 生成要读取的文件的路径
  2222.             fp = fopen(filepath, "r");  // 打开文件
  2223.             if (NULL != fp)
  2224.             {
  2225.                 fgets(filetext,sizeof(filetext),fp);    // 读取文件
  2226.                 if (strcmp(filetext,bm)==0)
  2227.                 {
  2228.                     closedir(dir);
  2229.                     return 1;
  2230.                 }
  2231.                 fclose(fp);
  2232.             }
  2233.         }
  2234.     }
  2235.     closedir(dir);  // 关闭路径
  2236.     return 0;
  2237. }
  2238.  
  2239. int uninstallapk(PACKAGENAME *bm)
  2240. {
  2241.     char ml[128];
  2242.     sprintf(ml,"pm uninstall %s",bm);
  2243.     system(ml);
  2244.     return 0;
  2245. }
  2246.  
  2247. int installapk(char *lj)
  2248. {
  2249.     char ml[128];
  2250.     sprintf(ml,"pm install %s",lj);
  2251.     system(ml);
  2252.     return 0;
  2253. }
  2254.  
  2255. int killprocess(PACKAGENAME *bm)
  2256. {
  2257.     int pid=getPID(bm);
  2258.     if (pid == 0)
  2259.     {
  2260.         return -1;
  2261.     }
  2262.     char ml[32];
  2263.     sprintf(ml,"kill %d",pid);
  2264.     system(ml);//杀掉进程
  2265.     return 0;
  2266. }
  2267.  
  2268. char GetProcessState(PACKAGENAME *bm)
  2269. {
  2270.     /*
  2271.         D. Kondisi tidur yang tidak dapat tidur (biasanya proses IO);
  2272.         R sedang berjalan, dalam antrian interruptible;
  2273.         S adalah dalam keadaan tidak aktif, keadaan statis;
  2274.         T Berhenti atau dilacak, tunda eksekusi;
  2275.         W memasuki swap memori (tidak valid sejak kernel 2.6);
  2276.         Proses mati X;
  2277.         Z Proses zombie tidak ada tetapi tidak bisa dihilangkan sementara waktu;
  2278.         W: Tidak ada cukup memori untuk paging
  2279.     */
  2280.     int pid=getPID(bm);//Dapatkan pid
  2281.     if (pid == 0)
  2282.     {
  2283.         return 0;//Tidak ada proses
  2284.     }
  2285.     FILE *fp;
  2286.     char lj[64];
  2287.     char buff[64];
  2288.     char zt;
  2289.     char zt1[16];
  2290.     sprintf(lj,"/proc/%d/status",pid);
  2291.     fp = fopen(lj,"r");//Buka file status
  2292.     if (fp == NULL)
  2293.     {
  2294.         return 0;//Tidak ada proses
  2295.     }
  2296.     //puts("loop");
  2297.     while (!feof(fp))
  2298.     {
  2299.         fgets(buff,sizeof(buff),fp);//Baca
  2300.         if (strstr(buff,"State"))//Saring
  2301.         {
  2302.             sscanf(buff,"State: %c",&zt);
  2303.             //printf("state:%c\n",zt);
  2304.             //sleep(1);
  2305.             //puts("emmmm");
  2306.             break;//Keluar dari lingkaran
  2307.         }
  2308.     }
  2309.     //putchar(zt);
  2310.     //puts(zt2);
  2311.     fclose(fp);
  2312.     //puts("loopopp");
  2313.     return zt;//Status pengembalian
  2314. }
  2315.  
  2316. int rebootsystem()
  2317. {
  2318.     return system("su -c 'reboot'");
  2319. }
  2320.  
  2321. int PutDate()
  2322. {
  2323.     return system("date +%F-%T");
  2324. }
  2325.  
  2326. int GetDate(char *date)
  2327. {
  2328.     FILE *fp;//Penunjuk file
  2329.     system("date +%F-%T > log.txt");//dilakukan
  2330.     if ((fp = fopen("log.txt", "r")) == NULL)
  2331.     {
  2332.         return 0;
  2333.     }
  2334.     fscanf(fp,"%s",date);//Baca
  2335.     remove("log.txt");//menghapus
  2336.     return 1;
  2337. }
  2338.  
  2339. void BypassGameSafe()
  2340. {
  2341.     system("echo 0 > /proc/sys/fs/inotify/max_user_watches");
  2342.     //char ml[80];
  2343.     //sprintf(ml,"chmod 444 /data/data/%s/files",bm);
  2344.     //system(ml);
  2345. }
  2346.  
  2347. int killGG()//杀掉GG修改器
  2348. {
  2349.     // Dalam / data / data / [nama paket pengubah GG] / file / ada nama folder adalah GG - ****
  2350. // Jika ada folder ini, dapatkan nama paket yang disebutkan di atas dan bunuh pengubah GG
  2351.     DIR *dir=NULL;
  2352.     DIR *dirGG=NULL;
  2353.     struct dirent *ptr=NULL;
  2354.     struct dirent *ptrGG=NULL;
  2355.     char filepath[256];         // Berapapun ukurannya, cukup instal path file cmdline
  2356.     char filetext[128];         // Berapapun ukurannya, Anda dapat memasang teks baris perintah untuk dikenali
  2357.     dir = opendir("/data/data");        // Jalur terbuka
  2358.     //puts("Membunuh GG");
  2359.     int flag=1;
  2360.     if (dir != NULL)
  2361.     {
  2362.         while (flag && (ptr = readdir(dir)) != NULL)    // Putar setiap file / folder di jalur
  2363.         {
  2364.             // Jika berbunyi "." Atau "..", lewati, dan jika itu tidak membaca nama folder, lewati
  2365.             if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
  2366.                 continue;
  2367.             if (ptr->d_type != DT_DIR)
  2368.                 continue;
  2369.             sprintf(filepath, "/data/data/%s/files", ptr->d_name);  // Hasilkan path file untuk dibaca
  2370.             dirGG = opendir(filepath);  // buka file
  2371.             if (dirGG != NULL)
  2372.             {
  2373.                 while ((ptrGG = readdir(dirGG)) != NULL)
  2374.                 {
  2375.                     if ((strcmp(ptrGG->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
  2376.                         continue;
  2377.                     if (ptrGG->d_type != DT_DIR)
  2378.                         continue;
  2379.                     if (strstr(ptrGG->d_name,"GG"))//Tentukan nama folder
  2380.                     {
  2381.                         int pid;//pid
  2382.                         pid = getPID(ptr->d_name);//Dapatkan nama paket GG
  2383.                         //ptr->d_name  Simpan nama file (yaitu, nama paket)
  2384.                         if (pid == 0)//Jika pid adalah 0, GG tidak berjalan
  2385.                             continue;
  2386.                         else//Jika pid berhasil diperoleh
  2387.                             killprocess(ptr->d_name);
  2388.                     }
  2389.                 }
  2390.             }
  2391.             /*else
  2392.             {
  2393.                 puts(filepath);//debugging
  2394.             }*/
  2395.         }
  2396.     }
  2397.     closedir(dir);  // mematikan
  2398.     closedir(dirGG);
  2399.     return 0;
  2400. }
  2401.  
  2402. int killXs()//Bunuh Xs
  2403. {
  2404.     DIR *dir=NULL;
  2405.     struct dirent *ptr=NULL;
  2406.     char filepath[256];         // Berapapun ukurannya, cukup instal path file cmdline
  2407.     char filetext[128];         // Berapapun ukurannya, Anda dapat memasang teks baris perintah untuk dikenali
  2408.     dir = opendir("/data/data");        // Jalur terbuka
  2409.     FILE *fp=NULL;
  2410.     if (NULL != dir)
  2411.     {
  2412.         while ((ptr = readdir(dir)) != NULL)    // Putar setiap file / folder di jalur
  2413.         {
  2414.             // Jika berbunyi"."atau".."Melewatkan,Lewati jika itu bukan nama folder
  2415.             if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
  2416.                 continue;
  2417.             if (ptr->d_type != DT_DIR)
  2418.                 continue;
  2419.                 ///data/data/%s/lib/libxscript.so
  2420.             sprintf(filepath, "/data/data/%s/lib/libxscript.so", ptr->d_name);  // 生成要读取的文件的路径
  2421.             fp=fopen(filepath,"r");
  2422.             if (fp == NULL)
  2423.                 continue;
  2424.             else//Jika bacaan berhasil (xs sedang berjalan)
  2425.             {
  2426.                 killprocess(ptr->d_name);
  2427.                 //Bunuh prosesnya
  2428.             }
  2429.                 //killprocess(ptr->d_name);
  2430.         }
  2431.     }
  2432.     closedir(dir);  // mematikan
  2433.     return 0;
  2434. }
  2435.  
  2436. /*void RecBypassGameSafe(char *bm)
  2437. {
  2438.     char ml[80];
  2439.     sprintf(ml,"chmod 771 /data/data/%s/files",bm);
  2440.     system(ml);
  2441. }*/
  2442. //xdrk
  2443. void *FreezeThread(void* a)
  2444. {
  2445.     int handle;
  2446.     int pid;
  2447.     pid=getPID(Fbm);
  2448.     if (pid == 0)
  2449.     {
  2450.         puts("Error -1");
  2451.         return (void*)0;
  2452.     }
  2453.     char lj[64];
  2454.     int buf_i;
  2455.     float buf_f;
  2456.     sprintf(lj,"/proc/%d/mem",pid);
  2457.     handle=open(lj,O_RDWR);
  2458.     if (handle == -1)
  2459.     {
  2460.         puts("Error -2");
  2461.         return (void*)0;
  2462.     }
  2463.     lseek(handle,0,SEEK_SET);
  2464.     PFREEZE pTemp=Pfreeze;
  2465.     while (Freeze == 1)
  2466.     {
  2467.         for (int i=0;i<FreezeCount;i++)
  2468.         {
  2469.             switch (pTemp->type)
  2470.             {
  2471.                 case DWORD:
  2472.                     buf_i=atoi(pTemp->value);
  2473.                     pwrite64(handle,&buf_i,4,pTemp->addr);
  2474.                     break;
  2475.                 case FLOAT:
  2476.                     buf_f=atof(pTemp->value);
  2477.                     pwrite64(handle,&buf_f,4,pTemp->addr);
  2478.                     break;
  2479.                 default:
  2480.                     break;
  2481.             }
  2482.             pTemp=pTemp->next;
  2483.             usleep(delay);
  2484.         }
  2485.         pTemp=Pfreeze;//Menunjuk kembali
  2486.     }
  2487.     return NULL;
  2488. }
  2489.  
  2490. PMAPS GetResults()//Dapatkan hasil pencarian
  2491. {
  2492.     if (Res == nullptr)
  2493.     {
  2494.         return nullptr;
  2495.     }
  2496.     else
  2497.     {
  2498.         return Res;//Kembalikan pointer kepala
  2499.     }
  2500. }
  2501.  
  2502. int AddFreezeItem_All(PACKAGENAME *bm,char *Value,TYPE type,OFFSET offset)
  2503. {
  2504.     if (ResCount == 0)
  2505.     {
  2506.         return -1;
  2507.     }
  2508.     PMAPS pTemp=Res;
  2509.     for (int i=0;i<ResCount;i++)
  2510.     {
  2511.         switch (type)
  2512.         {
  2513.             case DWORD:
  2514.                 AddFreezeItem(bm,pTemp->addr,Value,DWORD,offset);
  2515.                 break;
  2516.             case FLOAT:
  2517.                 AddFreezeItem(bm,pTemp->addr,Value,FLOAT,offset);
  2518.                 break;
  2519.             default:
  2520.                 SetTextColor(COLOR_SKY_BLUE);
  2521.                 puts("You Choose a NULL type");
  2522.                 break;
  2523.         }
  2524.         pTemp=pTemp->next;
  2525.     }
  2526.     return 0;
  2527. }
  2528.  
  2529. int AddFreezeItem(PACKAGENAME *bm,ADDRESS addr,char *value,TYPE type,OFFSET offset)
  2530. {
  2531.     switch (type)
  2532.     {
  2533.         case DWORD:
  2534.             AddFreezeItem_DWORD(bm,addr+offset,value);
  2535.             break;
  2536.         case FLOAT:
  2537.             AddFreezeItem_FLOAT(bm,addr+offset,value);
  2538.             break;
  2539.         default:
  2540.             SetTextColor(COLOR_SKY_BLUE);
  2541.             puts("You Choose a NULL type");
  2542.             break;
  2543.     }
  2544.     return 0;
  2545. }
  2546.  
  2547. int AddFreezeItem_DWORD(PACKAGENAME *bm,ADDRESS addr,char *value)
  2548. {
  2549.     if (FreezeCount == 0)//Jika tidak ada data
  2550.     {
  2551.         Pfreeze=pEnd=pNew=(PFREEZE)malloc(FRE);//Alokasikan ruang baru
  2552.         pNew->next=NULL;
  2553.         pEnd=pNew;
  2554.         Pfreeze=pNew;
  2555.         pNew->addr=addr;//Alamat toko
  2556.         pNew->type=DWORD;
  2557.         pNew->value=value;
  2558.         FreezeCount+=1;
  2559.     }
  2560.     else
  2561.     {
  2562.         pNew=(PFREEZE)malloc(FRE);//Alokasikan ruang
  2563.         pNew->next=NULL;
  2564.         pEnd->next=pNew;
  2565.         pEnd=pNew;
  2566.         pNew->addr=addr;
  2567.         pNew->type=DWORD;
  2568.         pNew->value=value;
  2569.         FreezeCount+=1;
  2570.     }
  2571.     return 0;
  2572. }
  2573.  
  2574. int AddFreezeItem_FLOAT(PACKAGENAME *bm,ADDRESS addr,char *value)
  2575. {
  2576.     if (FreezeCount == 0)//Jika tidak ada data
  2577.     {
  2578.         Pfreeze=pEnd=pNew=(PFREEZE)malloc(FRE);//Alokasikan ruang baru
  2579.         pNew->next=NULL;
  2580.         pEnd=pNew;
  2581.         Pfreeze=pNew;
  2582.         pNew->addr=addr;//Alamat toko
  2583.         pNew->type=FLOAT;
  2584.         pNew->value=value;
  2585.         FreezeCount+=1;
  2586.     }
  2587.     else
  2588.     {
  2589.         pNew=(PFREEZE)malloc(FRE);//Alokasikan ruang
  2590.         pNew->next=NULL;
  2591.         pEnd->next=pNew;
  2592.         pEnd=pNew;
  2593.         pNew->addr=addr;
  2594.         pNew->type=FLOAT;
  2595.         pNew->value=value;
  2596.         FreezeCount+=1;
  2597.     }
  2598.     return 0;
  2599. }
  2600.  
  2601. int RemoveFreezeItem(ADDRESS addr)
  2602. {
  2603.     PFREEZE pTemp=Pfreeze;
  2604.     PFREEZE p1=NULL;
  2605.     PFREEZE p2=NULL;
  2606.     for (int i=0;i<FreezeCount;i++)
  2607.     {
  2608.         p1=pTemp;
  2609.         p2=pTemp->next;
  2610.         if (pTemp->addr == addr)
  2611.         {
  2612.             p1->next=p2;
  2613.             free(pTemp);
  2614.             FreezeCount-=1;
  2615.             //printf("Jumlah pembekuan:%d\n",FreezeCount);
  2616.             //break;//Untuk mencegah pembekuan berulang dari alamat, jadi jangan menambahkan, tentu saja, Anda juga bisa menambahkan
  2617.         }
  2618.         pTemp=p2;
  2619.     }
  2620.     return 0;
  2621. }
  2622.  
  2623. int RemoveFreezeItem_All()
  2624. {
  2625.     PFREEZE pHead=Pfreeze;
  2626.     PFREEZE pTemp=pHead;
  2627.     int i;
  2628.     for (i=0;i<FreezeCount;i++)
  2629.     {
  2630.         pTemp=pHead;
  2631.         pHead=pHead->next;
  2632.         free(pTemp);
  2633.         FreezeCount-=1;
  2634.     }
  2635.     free(Pfreeze);
  2636.     FreezeCount-=1;
  2637.     return 0;
  2638. }
  2639.  
  2640. int StartFreeze(PACKAGENAME *bm)
  2641. {
  2642.     if (Freeze == 1)//Bekukan telah dihidupkan
  2643.     {
  2644.         return -1;
  2645.     }
  2646.     int a;
  2647.     strcpy(Fbm,bm);//******
  2648.     Freeze=1;
  2649.     pthread_create(&pth,NULL,FreezeThread,NULL);
  2650.     //Buat utas (mulai untuk membekukan utas)
  2651.     return 0;
  2652. }
  2653.  
  2654. int StopFreeze()
  2655. {
  2656.     Freeze=0;
  2657.     return 0;
  2658. }
  2659.  
  2660. int SetFreezeDelay(long int De)
  2661. {
  2662.     delay=De;
  2663.     return 0;
  2664. }
  2665.  
  2666. int PrintFreezeItems()
  2667. {
  2668.     PFREEZE pTemp=Pfreeze;
  2669.     for (int i=0;i<FreezeCount;i++)
  2670.     {
  2671.         printf("FreezeAddr:%lx,type:%s,value:%s\n",pTemp->addr,pTemp->type == DWORD ? "DWORD":"FLOAT",pTemp->value);
  2672.         pTemp=pTemp->next;
  2673.     }
  2674.     return 0;
  2675. }
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!