首页 › 分类存档 › 未分类

利用SVN实现自动版本号生成

第七根弦 2014 年 5 月 8 日 未分类 0

SVN是当前比较流行的版本控制软件，下面主要介绍通过SVN在程序编译时自动生成版本号。
基本思想：利用SubWCRev.exe获取版本信息，读入屏幕流，生成包括版本号信息的“.H文件”，并修改“.rc资源文件”中的版本信息，“.H文件”主要用于关于框中的版本显示，简单格式如下：
#ifndef __SVN_VERSION_MAX
#define __SVN_VERSION_MAX XXX
#endif
用下面附录的源码编译SVNVersionGen.exe

批处理使用说明：

MS DOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
setlocal
#设置TortoiseSVN安装目录
set SVN_PATH=D:\Program Files\TortoiseSVN\bin  
#设置解决方案目录
set WORK_DIR=e:\My Documents\Visual Studio Projects\XXX
#设置版本号，前三位
set VERSION_M="1,X,X"
set VERSION_S="1, X, X"
SVNVersionGen -HEADER "%SVN_PATH%" "%WORK_DIR%" "SVNVersion.h"
#设置子项目名称
set PRO1_NAME=PROJECT1
SVNVersionGen -RESVERSION "%SVN_PATH%" "%WORK_DIR%\%PRO1_NAME%" "%WORK_DIR%\%PRO1_NAME%\%PRO1_NAME%.rc" %VERSION_M% %VERSION_S%
#设置子项目2名称
set PRO1_NAME=PROJECT2
SVNVersionGen -RESVERSION "%SVN_PATH%" "%WORK_DIR%\%PRO1_NAME%" "%WORK_DIR%\%PRO1_NAME%\%PRO1_NAME%.rc" %VERSION_M% %VERSION_S%
endlocal

SVNVersionGen源代码

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
#include<string>
#include<windows.h>
#include<iostream>
using namespace std;
 
int GetSVNVersion( const char* pProPath,const char* pWorkDir,int& nVer,string& strOut )
{
nVer = 0;
string strInfo;
SECURITY_ATTRIBUTES sa;
HANDLE hRead,hWrite;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
if (!CreatePipe(&hRead,&hWrite,&sa,0))
{
return -1;
}
STARTUPINFO si;
PROCESS_INFORMATION pi;
si.cb = sizeof(STARTUPINFO);
GetStartupInfo(&si);
si.hStdError = hWrite;
si.hStdOutput = hWrite;
si.wShowWindow = SW_HIDE;
si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
char strPro[MAX_PATH];
sprintf( strPro,"%s\\SubWCRev.exe \"%s\"",pProPath,pWorkDir );
if (!CreateProcess(NULL,strPro,NULL,NULL,TRUE,NULL,NULL,NULL,&si,&pi))
{
return -1;
}
CloseHandle(hWrite);
char buffer[4096] = {0};
DWORD bytesRead;
while(true)
{
if(ReadFile(hRead,buffer,4095,&bytesRead,NULL) == NULL)
break;
strInfo += buffer;
Sleep(200);
}
char strCon[4096];
strcpy( strCon,"SubWCRev: '" );
strcat( strCon,pWorkDir );
strcat( strCon,"'\nLast committed at revision %d\n" );
sscanf( strInfo.c_str(),strCon,&nVer);
int nn = 0;
for( int i =0;i<strInfo.length();i++ )
{
if( strInfo[i] == '\n' )
{
nn++;
continue;
}
if( nn >= 3 )
{
break;
}
if( nn >= 2 )
{
if( strInfo[i] != '\r' )
strOut.push_back(strInfo[i]);
}
}
return 0;
}
 
int main(int argc, char* argv[])
{
if( argc < 2 )
{
return 0;
}
 
if( strcmp(argv[1],"-HEADER")==0 )
{
if( argc <= 4 )
{
return 0;
}
int nVer = 0;
string strOut;
GetSVNVersion( argv[2],argv[3],nVer,strOut );
cout<<nVer<<endl;
if( nVer > 0 )
{
FILE* f = fopen( argv[4],"w" );
if( f )
{
fprintf( f,"#ifndef __SVN_VERSION_MAX\n" );
fprintf( f,"#define __SVN_VERSION_MAX %d\n",nVer+1 );
fprintf( f,"static const int __SVN_VERSION = %d;\n",nVer+1 );
fprintf( f,"#endif\n" );
fclose(f);
MessageBox(0,"成功生成版本头文件","",0);
}
}
else
{
MessageBox(0,"生成版本头文件失败","",0);
}
return 0;
}
else if( strcmp(argv[1],"-RESVERSION")==0 )
{
if( argc <= 6 )
{
MessageBox(0,"更新资源文件版本号失败","",0);
return 0;
}
int nVer = 0;
string strOut;
GetSVNVersion( argv[2],argv[3],nVer,strOut );
//MessageBox(0,strOut.c_str(),"",0);
if( nVer <= 0 )
{
MessageBox(0,argv[4],"更新资源文件版本号失败",0);
return 0;
}
nVer ++;
char buf[4096];
char fileo[MAX_PATH];
strcpy( fileo,argv[4] );
strcat( fileo,".o");
FILE* fw = fopen( fileo,"w" );
FILE* f = fopen( argv[4],"r" );
while( fgets(buf,sizeof(buf),f) > 0 )
{
char* p = NULL;
if( (p=strstr(buf, "            VALUE \"Comments\"")) != NULL )
{
fprintf( fw,"            VALUE \"Comments\", \"%s\"\n",strOut.c_str());
printf("%s",p);
continue;
}
else if( (p=strstr(buf, " FILEVERSION ")) != NULL )
{
fprintf( fw," FILEVERSION %s,%d\n",argv[5],nVer);
printf("%s",p);
continue;
}
else if( (p=strstr(buf, " PRODUCTVERSION ")) != NULL )
{
fprintf( fw," PRODUCTVERSION %s,%d\n",argv[5],nVer);
printf("%s",p);
continue;
}
else if( (p=strstr(buf, "            VALUE \"FileVersion\", ")) != NULL )
{
fprintf( fw,"            VALUE \"FileVersion\", \"%s, %d\"\n",argv[6],nVer);
printf("%s",p);
continue;
}
else if( (p=strstr(buf, "            VALUE \"ProductVersion\"")) != NULL )
{
fprintf( fw,"            VALUE \"ProductVersion\", \"%s ,%d\"\n",argv[6],nVer);
printf("%s",p);
continue;
}
fprintf( fw,"%s",buf );
}
fclose( f );
fclose( fw );
char filebak[MAX_PATH];
strcpy( filebak,argv[4] );
strcat( filebak,".bak");
::DeleteFile( filebak );
rename( argv[4],filebak );
::DeleteFile( argv[4] );
rename( fileo,argv[4] );
MessageBox(0,argv[4],"成功更新版本号",0);
}
}

SVNVersionGen.rar下载

c语言读写ini

第七根弦 2014 年 5 月 8 日 未分类 0
一共四个文件：inifile.c,inifile.h,main.c.程序中用到的配置文件myconfig.ini不需要提前存在，代码中有创建的过程。
inifile.h是inifile.c的头文件完成读写配置文件的功能，main.c调用inifile完成的功能。

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// inifile.h
/**
* @file
* @brief initialization file read and write API
* -size of the ini file must less than 16K
* -after '=' in key value pair, can not support empty char. this would not like WIN32 API
* -support comment using ';' prefix
* -can not support multi line
* @author Deng Yangjun
* @date 2007-1-9
* @version 0.2
*/
 
#ifndef INI_FILE_H_
#define INI_FILE_H_
#ifdef __cplusplus
extern "C"
{
#endif
int read_profile_string( const char *section, const char *key,char *value, int size,const char *default_value, const char *file);
int read_profile_int( const char *section, const char *key,int default_value, const char *file);
int write_profile_string( const char *section, const char *key,const char *value, const char *file);
#ifdef __cplusplus
}; //end of extern "C" {
#endif
#endif //end of INI_FILE_H_

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
inifile.c
/**
* @file
* @brief initialization file read and write API implementation
* @author Deng Yangjun
* @date 2007-1-9
* @version 0.2
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include "inifile.h"
#ifdef __cplusplus
extern "C"
{
#endif
#define MAX_FILE_SIZE 1024*16
#define LEFT_BRACE '['
#define RIGHT_BRACE ']'
static int load_ini_file(const char *file, char *buf,int *file_size)
{
FILE *in = NULL;
int i=0;
*file_size =0;
assert(file !=NULL);
assert(buf !=NULL);
in = fopen(file,"r");
if( NULL == in) {
return 0;
}
buf[i]=fgetc(in);
//load initialization file
while( buf[i]!= (char)EOF) {
i++;
assert( i < MAX_FILE_SIZE ); //file too big, you can redefine MAX_FILE_SIZE to fit the big file
buf[i]=fgetc(in);
}
buf[i]='\0';
*file_size = i;
fclose(in);
return 1;
}
static int newline(char c)
{
return ('\n' == c || '\r' == c )? 1 : 0;
}
static int end_of_string(char c)
{
return '\0'==c? 1 : 0;
}
static int left_barce(char c)
{
return LEFT_BRACE == c? 1 : 0;
}
static int isright_brace(char c )
{
return RIGHT_BRACE == c? 1 : 0;
}
static int parse_file(const char *section, const char *key, const char *buf,int *sec_s,int *sec_e,
int *key_s,int *key_e, int *value_s, int *value_e)
{
const char *p = buf;
int i=0;
assert(buf!=NULL);
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));
*sec_e = *sec_s = *key_e = *key_s = *value_s = *value_e = -1;
while( !end_of_string(p[i]) ) {
//find the section
if( ( 0==i || newline(p[i-1]) ) && left_barce(p[i]) )
{
int section_start=i+1;
//find the ']'
do {
i++;
} while( !isright_brace(p[i]) && !end_of_string(p[i]));
if( 0 == strncmp(p+section_start,section, i-section_start)) {
int newline_start=0;
i++;
//Skip over space char after ']'
while(isspace(p[i])) {
i++;
}
//find the section
*sec_s = section_start;
*sec_e = i;
while( ! (newline(p[i-1]) && left_barce(p[i]))
&& !end_of_string(p[i]) ) {
int j=0;
//get a new line
newline_start = i;
while( !newline(p[i]) && !end_of_string(p[i]) ) {
i++;
}
 
//now i is equal to end of the line
j = newline_start;
if(';' != p[j]) //skip over comment
{
while(j < i && p[j]!='=') {
j++;
if('=' == p[j]) {
if(strncmp(key,p+newline_start,j-newline_start)==0)
{
//find the key ok
*key_s = newline_start;
*key_e = j-1;
*value_s = j+1;
*value_e = i;
return 1;
}
}
}
}
i++;
}
}
}
else
{
i++;
}
}
return 0;
}
/**
read string in initialization file\n
* retrieves a string from the specified section in an initialization file
section [in] name of the section containing the key name
key [in] name of the key pairs to value
value [in] pointer to the buffer that receives the retrieved string
size [in] size of result's buffer
default_value [in] default value of result
file [in] path of the initialization file
1 : read success; \n 0 : read fail
*/
int read_profile_string( const char *section, const char *key,char *value,
int size, const char *default_value, const char *file)
{
char buf[MAX_FILE_SIZE]={0};
int file_size;
int sec_s,sec_e,key_s,key_e, value_s, value_e;
//check parameters
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));
assert(value != NULL);
assert(size > 0);
assert(file !=NULL &&strlen(key));
if(!load_ini_file(file,buf,&file_size))
{
if(default_value!=NULL)
{
strncpy(value,default_value, size);
}
return 0;
}
if(!parse_file(section,key,buf,&sec_s,&sec_e,&key_s,&key_e,&value_s,&value_e))
{
if(default_value!=NULL)
{
strncpy(value,default_value, size);
}
return 0; //not find the key
}
else
{
int cpcount = value_e -value_s;
if( size-1 < cpcount)
{
cpcount = size-1;
}
memset(value, 0, size);
memcpy(value,buf+value_s, cpcount );
value[cpcount] = '\0';
return 1;
}
}
/**
read int value in initialization file\n
* retrieves int value from the specified section in an initialization file
section [in] name of the section containing the key name
key [in] name of the key pairs to value
default_value [in] default value of result
file [in] path of the initialization file
profile int value,if read fail, return default value
*/
int read_profile_int( const char *section, const char *key,int default_value,
const char *file)
{
char value[32] = {0};
if(!read_profile_string(section,key,value, sizeof(value),NULL,file))
{
return default_value;
}
else
{
return atoi(value);
}
}
/**
* @brief write a profile string to a ini file
* @param section [in] name of the section,can't be NULL and empty string
* @param key [in] name of the key pairs to value, can't be NULL and empty string
* @param value [in] profile string value
* @param file [in] path of ini file
* @return 1 : success\n 0 : failure
*/
int write_profile_string(const char *section, const char *key, const char *value, const char *file)
{
char buf[MAX_FILE_SIZE]={0};
char w_buf[MAX_FILE_SIZE]={0};
int sec_s,sec_e,key_s,key_e, value_s, value_e;
int value_len = (int)strlen(value);
int file_size;
FILE *out;
//check parameters
assert(section != NULL && strlen(section));
assert(key != NULL && strlen(key));
assert(value != NULL);
assert(file !=NULL &&strlen(key));
if(!load_ini_file(file,buf,&file_size))
{
sec_s = -1;
}
else
{
parse_file(section,key,buf,&sec_s,&sec_e,&key_s,&key_e,&value_s,&value_e);
}
if( -1 == sec_s)
{
if(0==file_size)
{
sprintf(w_buf+file_size,"[%s]\n%s=%s\n",section,key,value);
}
else
{
//not find the section, then add the new section at end of the file
memcpy(w_buf,buf,file_size);
sprintf(w_buf+file_size,"\n[%s]\n%s=%s\n",section,key,value);
}
}
else if(-1 == key_s)
{
//not find the key, then add the new key=value at end of the section
memcpy(w_buf,buf,sec_e);
sprintf(w_buf+sec_e,"%s=%s\n",key,value);
sprintf(w_buf+sec_e+strlen(key)+strlen(value)+2,buf+sec_e, file_size - sec_e);
}
else
{
//update value with new value
memcpy(w_buf,buf,value_s);
memcpy(w_buf+value_s,value, value_len);
memcpy(w_buf+value_s+value_len, buf+value_e, file_size - value_e);
}
out = fopen(file,"w");
if(NULL == out)
{
return 0;
}
if(-1 == fputs(w_buf,out) )
{
fclose(out);
return 0;
}
fclose(out);
return 1;
}
#ifdef __cplusplus
}; //end of extern "C" {
#endif

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// main.c
#include <stdio.h>
#include "inifile.h"
 
#define BUF_SIZE 256
 
int main()
{
const char *file ="myconfig.ini";//这里也可以改成“myconfig,txt”
const char *section = "student";
const char *name_key = "name";
const char *age_key = "age";
char name[BUF_SIZE]={0};
int age;
 
//write name key value pair
if(!write_profile_string(section,name_key,"Tony",file))
{
printf("write name pair to ini file fail\n");
return -1;
}
//write age key value pair
if(!write_profile_string(section,age_key,"20",file))
{
printf("write age pair to ini file fail\n");
return -1;
}
 
printf("[%s]\n",section);
//read string pair, test read string value
if(!read_profile_string(section, name_key, name, BUF_SIZE,"",file))
{
printf("read ini file fail\n");
return -1;
}
else
{
printf("%s=%s\n",name_key,name);
}
//read age pair, test read int value.
//if read fail, return default value
age = read_profile_int(section,age_key,0,file);
printf("%s=%d\n",age_key,age);
 
return 0;
}

C++著名程序库的比较和学习经验

第七根弦 2014 年 5 月 5 日 未分类 0

1、C++各大有名库的介绍——C++标准库
2、C++各大有名库的介绍——准标准库Boost
3、C++各大有名库的介绍——GUI
4、C++各大有名库的介绍——网络通信
5、C++各大有名库的介绍——XML
6、C++各大有名库的介绍——科学计算
7、C++各大有名库的介绍——游戏开发
8、C++各大有名库的介绍——线程
9、C++各大有名库的介绍——序列化
10、C++各大有名库的介绍——字符串
11、C++各大有名库的介绍——综合
12、C++各大有名库的介绍——其他库
13、C++名人的网站

在 C++中，库的地位是非常高的。C++之父 Bjarne Stroustrup先生多次表示了设计库来扩充功能要好过设计更多的语法的言论。现实中，C++的库门类繁多，解决的问题也是极其广泛，库从轻量级到重 量级的都有。不少都是让人眼界大开，亦或是望而生叹的思维杰作。由于库的数量非常庞大，而且限于笔者水平，其中很多并不了解。所以文中所提的一些库都是比 较著名的大型库。

1、C++各大有名库的介绍——C++标准库

标准库中提供了C++程序的基本设施。虽然C++标准库随着C++标准折腾了许多年，直到标准的出台才正式定型，但是在标准库的实现上却很令人欣慰得看到多种实现，并且已被实践证明为有工业级别强度的佳作。
1.1、Dinkumware C++ Library

参考站点：http://www.dinkumware.com/

P.J. Plauger编写的高品质的标准库。P.J. Plauger博士是Dr. Dobb’s程序设计杰出奖的获得者。其编写的库长期被Microsoft采用，并且最近Borland也取得了其OEM的license，在其 C/C++的产品中采用Dinkumware的库。

1.2、RogueWave Standard C++ Library

参考站点：http://www.roguewave.com/

这个库在Borland C++ Builder的早期版本中曾经被采用，后来被其他的库给替换了。笔者不推荐使用。

1.3、SGI STL

参考站点：http://www.roguewave.com/

SGI公司的C++标准模版库。

1.4、STLport

参考站点：http://www.stlport.org/

SGI STL库的跨平台可移植版本。

2、C++各大有名库的介绍——准标准库Boost

Boost库是一个经过千锤百炼、可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的发动机之一。 Boost库由C++标准委员会库工作组成员发起，在C++社区中影响甚大，其成员已近2000人。 Boost库为我们带来了最新、最酷、最实用的技术，是不折不扣的“准”标准库。Boost中比较有名气的有这么几个库：

2.1 Regex  正则表达式库

2.2 Spirit   LL parser framework，用C++代码直接表达EBNF

2.3 Graph  图组件和算法

2.4 Lambda  在调用的地方定义短小匿名的函数对象，很实用的functional功能

2.5 concept check   检查泛型编程中的concept

2.6 Mpl   用模板实现的元编程框架

2.7 Thread   可移植的C++多线程库

2.8 Python   把C++类和函数映射到Python之中

2.9 Pool    内存池管理

2.10 smart_ptr   5个智能指针，学习智能指针必读，一份不错的参考是来自CUJ的文章：

Smart Pointers in Boost,哦，这篇文章可以查到，CUJ是提供在线浏览的。中文版见笔者在《Dr.Dobb’s Journal软件研发杂志》第7辑上的译文。

Boost总体来说是实用价值很高，质量很高的库。并且由于其对跨平台的强调，对标准C++的强调，是编写平台无关，现代C++的开发者必备的 工具。但是Boost中也有很多是实验性质的东西，在实际的开发中实用需要谨慎。并且很多Boost中的库功能堪称对语言功能的扩展，其构造用尽精巧的手 法，不要贸然的花费时间研读。Boost另外一面，比如Graph这样的库则是具有工业强度，结构良好，非常值得研读的精品代码，并且也可以放心的在产品 代码中多多利用。

参考站点：http://www.boost.org

3、C++各大有名库的介绍——GUI

在众多C++的库中，GUI部分的库算是比较繁荣，也比较引人注目的。在实际开发中，GUI库的选择也是非常重要的一件事情，下面我们综述一下可选择的GUI库，各自的特点以及相关工具的支持。3.1、MFC

大名鼎鼎的微软基础类库（Microsoft Foundation Class）。大凡学过VC++的人都应该知道这个库。虽然从技术角度讲，MFC是不大漂亮的，但是它构建于Windows API 之上，能够使程序员的工作更容易,编程效率高，减少了大量在建立 Windows 程序时必须编写的代码，同时它还提供了所有一般 C++ 编程的优点，例如继承和封装。MFC 编写的程序在各个版本的Windows操作系统上是可移植的，例如，在Windows 3.1下编写的代码可以很容易地移植到 Windows NT 或 Windows 95 上。但是在最近发展以及官方支持上日渐势微。

3.2、QT

参考网站：http://www.trolltech.com

Qt是Trolltech公司的一个多平台的C++图形用户界面应用程序框架。它提供给应用程序开发者建立艺术级的图形用户界面所需的所用功 能。Qt是完全面向对象的很容易扩展，并且允许真正地组件编程。自从1996年早些时候，Qt进入商业领域，它已经成为全世界范围内数千种成功的应用程序 的基础。Qt也是流行的Linux桌面环境KDE 的基础，同时它还支持Windows、Macintosh、Unix/X11等多种平台。[wangxinus注:QT目前已经是Nokia旗下的产品，原官方网站已经失效，目前为http://qt.nokia.com.2009年初发布的Qt4.5版本开始使用LGPL协议，诺基亚希望以此来吸引更多的开发人员使用Qt库]

3.3、WxWindows

参考网站：http://www.wxwindows.org

跨平台的GUI库。因为其类层次极像MFC，所以有文章介绍从MFC到WxWindows的代码移植以实现跨平台的功能。通过多年的开发也是一个日趋完善的GUI库，支持同样不弱于前面两个库。并且是完全开放源代码的。新近的C++ Builder X的GUI设计器就是基于这个库的。[wangxinus注:迫于微软的施压，已经由WxWindows更名为wxWidgets]

3.4、Fox

参考网站：http://www.fox-toolkit.org/

开放源代码的GUI库。作者从自己亲身的开发经验中得出了一个理想的GUI库应该是什么样子的感受出发，从而开始了对这个库的开发。有兴趣的可以尝试一下。

3.5、WTL

基于ATL的一个库。因为使用了大量ATL的轻量级手法，模板等技术，在代码尺寸，以及速度优化方面做得非常到位。主要面向的使用群体是开发COM轻量级供网络下载的可视化控件的开发者。

3.6、GTK

参考网站：http://gtkmm.sourceforge.net/

GTK是一个大名鼎鼎的C的开源GUI库。在Linux世界中有Gnome这样的杀手应用。而Qt就是这个库的C++封装版本。[wangxinus注:“Qt 就是这个库的C++封装版本”是错误的。Qt早于GTK，最初Qt由于协议的原因引起社区的不满，另外开发了一个基于C语言的GTK库，后面的扩展版本为 GTK＋。GTK+的Gnome和Qt的KDE是目前linux桌面的两大阵营，曾有水火不容之势。目前双方都以及开源社区的精神，已经和解。]

4、C++各大有名库的介绍——网络通信

4.１、ACE

参考网站：http://www.cs.wustl.edu/~schmidt/ACE.html

C++库的代表，超重量级的网络通信开发框架。ACE自适配通信环境（Adaptive Communication Environment）是可以自由使用、开放源代码的面向对象框架，在其中实现了许多用于并发通信软件的核心模式。ACE提供了一组丰富的可复用C++ 包装外观（Wrapper Facade）和框架组件，可跨越多种平台完成通用的通信软件任务，其中包括：事件多路分离和事件处理器分派、信号处理、服务初始化、进程间通信、共享内存管理、消息路由、分布式服务动态（重）配置、并发执行和同步，等等。

4.２、StreamModule

参考网站：http://www.omnifarious.org/StrMod

设计用于简化编写分布式程序的库。尝试着使得编写处理异步行为的程序更容易，而不是用同步的外壳包起异步的本质。

4.３、SimpleSocket

参考网站：http://home.hetnet.nl/~lcbokkers/simsock.htm

这个类库让编写基于socket的客户/服务器程序更加容易。

4.４、A Stream Socket API for C++

参考网站：http://www.pcs.cnu.edu/~dgame/sockets/socketsC++/sockets.html

又一个对Socket的封装库。

5、C++各大有名库的介绍——XML

5.１、Xerces

参考网站：http://xml.apache.org/xerces-c/

Xerces-C++ 是一个非常健壮的XML解析器，它提供了验证，以及SAX和DOM API。XML验证在文档类型定义(Document Type Definition，DTD)方面有很好的支持，并且在2001年12月增加了支持W3C XMLSchema 的基本完整的开放标准。

5.２、XMLBooster

参考网站：http://www.xmlbooster.com/

这个库通过产生特制的parser的办法极大的提高了XML解析的速度，并且能够产生相应的GUI程序来修改这个parser。在DOM和SAX两大主流XML解析办法之外提供了另外一个可行的解决方案。

5.３、Pull Parser

参考网站：http://www.extreme.indiana.edu/xgws/xsoap/xpp

这个库采用pull方法的parser。在每个SAX的parser底层都有一个pull的parser，这个xpp把这层暴露出来直接给大家使用。在要充分考虑速度的时候值得尝试。

5.４、Xalan

参考网站：http://xml.apache.org/xalan-c/

Xalan是一个用于把XML文档转换为HTML，纯文本或者其他XML类型文档的XSLT处理器。

5.５、CMarkup

参考网站：http://www.firstobject.com/xml.htm

这是一种使用EDOM的XML解析器。在很多思路上面非常灵活实用。值得大家在DOM和SAX之外寻求一点灵感。

5.６、libxml++

http://libxmlplusplus.sourceforge.net/

libxml++是对著名的libxml XML解析器的C++封装版本。

5.7. TinyXML [wangxinus注:一个非常小巧的XML解析库，基于DOM的。]

6、C++各大有名库的介绍——科学计算

6.１、Blitz++

参考网站：http://www.oonumerics.org/blitz

Blitz++ 是一个高效率的数值计算函数库，它的设计目的是希望建立一套既具像C++ 一样方便，同时又比Fortran速度更快的数值计算环境。通常，用C++所写出的数值程序，比 Fortran慢20%左右，因此Blitz++正是要改掉这个缺点。方法是利用C++的template技术，程序执行甚至可以比Fortran更快。

Blitz++目前仍在发展中，对于常见的SVD，FFTs，QMRES等常见的线性代数方法并不提供，不过使用者可以很容易地利用Blitz++所提供的函数来构建。

6.２、POOMA

参考网站：http://www.codesourcery.com/pooma/pooma

POOMA是一个免费的高性能的C++库，用于处理并行式科学计算。POOMA的面向对象设计方便了快速的程序开发，对并行机器进行了优化以达到最高的效率，方便在工业和研究环境中使用。

6.３、MTL

参考网站：http://www.osl.iu.edu/research/mtl

Matrix Template Library(MTL)是一个高性能的泛型组件库，提供了各种格式矩阵的大量线性代数方面的功能。在某些应用使用高性能编译器的情况下，比如Intel的编译器，从产生的汇编代码可以看出其与手写几乎没有两样的效能。

6.４、CGAL

参考网站：www.cgal.org

Computational Geometry Algorithms Library的目的是把在计算几何方面的大部分重要的解决方案和方法以C++库的形式提供给工业和学术界的用户。

7、C++各大有名库的介绍——游戏开发

7.１、Audio/Video 3D C++ Programming Library

参考网站：http://www.galacticasoftware.com/products/av/

AV3D是一个跨平台，高性能的C++库。主要的特性是提供3D图形，声效支持（SB,以及S3M），控制接口（键盘，鼠标和遥感），XMS。

7.２、KlayGE

参考网站：http://home.g365.net/enginedev/

国内游戏开发高手自己用C++开发的游戏引擎。KlayGE是一个开放源代码、跨平台的游戏引擎，并使用Python作脚本语言。KlayGE在LGPL协议下发行。感谢龚敏敏先生为中国游戏开发事业所做出的贡献。

[wangxinus注:这个库国人了解很少，百度百科的KlayGE词条还是本人创建的。一个人开发一个游戏引擎库，是在让笔者汗颜，对作者表示钦佩！]

7.３、OGRE

参考网站：http://www.ogre3d.org

OGRE（面向对象的图形渲染引擎）是用C++开发的，使用灵活的面向对象3D引擎。它的目的是让开发者能更方便和直接地开发基于3D硬件设备 的应用程序或游戏。引擎中的类库对更底层的系统库（如：Direct3D和OpenGL）的全部使用细节进行了抽象，并提供了基于现实世界对象的接口和其 它类。

8、C++各大有名库的介绍——线程

8.１、C++ Threads

参考网站：http://threads.sourceforge.net/

这个库的目标是给程序员提供易于使用的类，这些类被继承以提供在Linux环境中很难看到的大量的线程方面的功能。

8.２、ZThreads

参考网站：http://zthread.sourceforge.net/

一个先进的面向对象，跨平台的C++线程和同步库。

9、C++各大有名库的介绍——序列化

9.１、s11n

参考网站：http://s11n.net/

一个基于STL的C++库，用于序列化POD，STL容器以及用户定义的类型。

9.２、Simple XML Persistence Library

参考网站：http://sxp.sourceforge.net/

这是一个把对象序列化为XML的轻量级的C++库。

10、C++各大有名库的介绍——字符串

10.１、C++ Str Library

参考网站：http://www.utilitycode.com/str/

操作字符串和字符的库，支持Windows和支持gcc的多种平台。提供高度优化的代码，并且支持多线程环境和Unicode，同时还有正则表达式的支持。

10.２、Common Text Transformation Library

参考网站：http://cttl.sourceforge.net/

这是一个解析和修改STL字符串的库。CTTL substring类可以用来比较，插入，替换以及用EBNF的语法进行解析。

10.３、GRETA

参考网站：http://research.microsoft.com/projects/greta/

这是由微软研究院的研究人员开发的处理正则表达式的库。在小型匹配的情况下有非常优秀的表现。

11、C++各大有名库的介绍——综合

11.１、P::Classes

参考网站：http://pclasses.com/

一个高度可移植的C++应用程序框架。当前关注类型和线程安全的signal/slot机制，i/o系统包括基于插件的网络协议透明的i/o架构，基于插件的应用程序消息日志框架，访问sql数据库的类等等。

11.２、ACDK – Artefaktur Component Development Kit

参考网站：http://acdk.sourceforge.net/

这是一个平台无关的C++组件框架，类似于Java或者.NET中的框架（反射机制，线程，Unicode，废料收集，I/O，网络，实用工具，XML，等等），以及对Java, Perl, Python, TCL, Lisp, COM 和 CORBA的集成。

11.３、dlib C++ library

参考网站：http://www.cis.ohio-state.edu/~kingd/dlib/

各种各样的类的一个综合。大整数，Socket，线程，GUI，容器类,以及浏览目录的API等等。

11.４、Chilkat C++ Libraries

参考网站：http://www.chilkatsoft.com/cpp_libraries.asp

这是提供zip，e-mail，编码，S/MIME，XML等方面的库。

11.５、C++ Portable Types Library (PTypes)

参考网站：http://www.melikyan.com/ptypes/

这是STL的比较简单的替代品，以及可移植的多线程和网络库。

11.６、LFC

参考网站：http://lfc.sourceforge.net/

哦，这又是一个尝试提供一切的C++库

12、C++各大有名库的介绍——其他库

12.１、Loki

参考网站：http://www.moderncppdesign.com/

哦，你可能抱怨我早该和Boost一起介绍它，一个实验性质的库。作者在loki中把C++模板的功能发挥到了极致。并且尝试把类似设计模式这样思想层面的东西通过库来提供。同时还提供了智能指针这样比较实用的功能。

12.２、ATL

ATL(Active Template Library)是一组小巧、高效、灵活的类，这些类为创建可互操作的COM组件提供了基本的设施。

12.３、FC++: The Functional C++ Library

这个库提供了一些函数式语言中才有的要素。属于用库来扩充语言的一个代表作。如果想要在OOP之外寻找另一分的乐趣，可以去看看函数式程序设计的世界。大师Peter Norvig在 “Teach Yourself Programming in Ten Years”一文中就将函数式语言列为至少应当学习的6类编程语言之一。

12.４、FACT!

参考网站：http://www.kfa-juelich.de/zam/FACT/start/index.html

另外一个实现函数式语言特性的库

12.５、Crypto++

提供处理密码，消息验证，单向hash，公匙加密系统等功能的免费库。

还有很多非常激动人心或者是极其实用的C++库，限于我们的水平以及文章的篇幅不能包括进来。在对于这些已经包含近来的库的介绍中，由于并不是每一个我们都使用过，所以难免有偏颇之处，请读者见谅。

13、C++名人的网站
正如我们可以通过计算机历史上的重要人物了解计算机史的发展，C++相关人物的网站也可以使我们得到最有价值的参考与借鉴，下面的人物我们认为没 有介绍的必要，只因下面的人物在C++领域的地位众所周知，我们只将相关的资源进行罗列以供读者学习，他们有的工作于贝尔实验室，有的工作于知名编译器厂 商，有的在不断推进语言的标准化，有的为读者撰写了多部千古奇作……

１、Bjarne Stroustrup

http://www.research.att.com/~bs/

２、Stanley B. Lippman

http://blogs.msdn.com/slippman/ (中文版)

http://www.zengyihome.net/slippman/index.htm

３、Scott Meyers

http://www.aristeia.com/

４、David Musser

http://www.cs.rpi.edu/~musser/

５、Bruce Eckel

http://www.bruceeckel.com

http://blog.csdn.net/beckel Bruce Eckel 博客中文版

６、Nicolai M. Josuttis

http://www.josuttis.com/

７、Herb Sutter

http://www.gotw.ca/

http://blog.csdn.net/hsutter/ Herb Sutter 中文博客

８、Andrei Alexandrescu

http://www.moderncppdesign.com

Linux tcpdump命令详解

第七根弦 2014 年 4 月 23 日 未分类 1

简介
用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。
继续阅读 »

CentOS下搭建NGINX+SVN

第七根弦 2014 年 3 月 24 日 未分类 0

因为没有什么可以定制的， 所以svn直接使用系统自带的包管理软件安装，
以centos系列为例， 命令如下：

Shell
1
yum install subversion

然后是nginx的安装：

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
mkdir -p /opt/soft
groupadd web
useradd http -g web -s /sbin/nologin
cd /opt/soft
wget http://sourceforge.net/projects/pcre/files/pcre/8.12/pcre-8.12.tar.gz
wget http://www.openssl.org/source/openssl-1.0.0d.tar.gz
tar zxvf pcre-8.12.tar.gz
tar zxvf openssl-1.0.0d.tar.gz
tar zxvf nginx-0.8.54.tar.gz
cd nginx-0.8.54
./configure --prefix=/opt/nginx --user=http --group=web --with-http_stub_status_module --with-http_ssl_module --with-md5=/usr/lib/ --with-pcre=/opt/soft/pcre-8.12 --with-openssl=/opt/soft/openssl-1.0.0d
make
make install

root 指定到/data/wwwroot

Shell
1
vi /opt/nginx/conf/nginx.conf

创建svn仓库：

Shell
1
svnadmin create /data/svn

修改配置文件：

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
vi /data/svn/conf/authz
[groups]
admin=test #admin组里的成员
[/]
test = rw #成员对/目录的权限： r读，w写
vi /data/svn/conf/passwd
[users]
test = 123456 #用户test的密码
vi /data/svn/conf/svnserve.conf
anon-access = none
auth-access = write
password-db = passwd
authz-db = authz
realm = My First Repository

启动svnserv

Shell
1
svnserve -d -r /data/svn

也可以使用–listen-port参数指定端口，启动多个仓库
导入项目，假如项目目录为svn://host/test ,创建svn仓库副本(nginx的读取目录)

Shell
1
2
cd /data/wwwroot
svn co svn://localhost/test --username test --password 123456

设置svn更新后自动更新nginx的读取目录:

Shell
1
2
3
4
vi /data/svn/hooks/post-commit
#!/bin/sh
svn up /opt/www/test/ --username "lyf" --password "123456"
chown -R http:web /opt/www #这一步或许可以滤过

给脚本增加可执行权限

Shell
1
chmod +x /data/svn/hooks/post-commit

大功告成, 现在可以测试一下了，svn更新后nginx读取到的内容(访问http)也随之变化, 是不是比apache还有简单

nginx rewrite规则和参考

第七根弦 2014 年 3 月 21 日 未分类 0

正则表达式匹配，其中：

* ~ 为区分大小写匹配
* ~* 为不区分大小写匹配
* !~和!~*分别为区分大小写不匹配及不区分大小写不匹配

文件及目录匹配，其中：

* -f和!-f用来判断是否存在文件
* -d和!-d用来判断是否存在目录
* -e和!-e用来判断是否存在文件或目录
* -x和!-x用来判断文件是否可执行

flag标记有：

* last 相当于Apache里的[L]标记，表示完成rewrite
* break 终止匹配, 不再匹配后面的规则
* redirect 返回302临时重定向 地址栏会显示跳转后的地址
* permanent 返回301永久重定向 地址栏会显示跳转后的地址

一些可用的全局变量有，可以用做条件判断(待补全)

$args
$content_length
$content_type
$document_root
$document_uri
$host
$http_user_agent
$http_cookie
$limit_rate
$request_body_file
$request_method
$remote_addr
$remote_port
$remote_user
$request_filename
$request_uri
$query_string
$scheme
$server_protocol
$server_addr
$server_name
$server_port
$uri

结合QeePHP的例子

Shell
1
2
3
4
    if (!-d $request_filename) {
    rewrite ^/([a-z-A-Z]+)/([a-z-A-Z]+)/?(.*)$ /index.php?namespace=user&amp;controller=$1&amp;action=$2&amp;$3 last;
    rewrite ^/([a-z-A-Z]+)/?$ /index.php?namespace=user&amp;controller=$1 last;
    break;

多目录转成参数

Shell
1
2
3
4
5
6
abc.domian.com/sort/2 => abc.domian.com/index.php?act=sort&name=abc&id=2
 
    if ($host ~* (.*)\.domain\.com) {
    set $sub_name $1;
    rewrite ^/sort\/(\d+)\/?$ /index.php?act=sort&cid=$sub_name&id=$1 last;
    }

目录对换

Shell
1
2
3
/123456/xxxx -> /xxxx?id=123456
 
    rewrite ^/(\d+)/(.+)/ /$2?id=$1 last;

例如下面设定nginx在用户使用ie的使用重定向到/nginx-ie目录下：

Shell
1
2
3
    if ($http_user_agent ~ MSIE) {
    rewrite ^(.*)$ /nginx-ie/$1 break;
    }

目录自动加“/”

Shell
1
2
3
    if (-d $request_filename){
    rewrite ^/(.*)([^/])$ http://$host/$1$2/ permanent;
    }

禁止htaccess

Shell
1
2
3
    location ~/\.ht {
    deny all;
    }

禁止多个目录

Shell
1
2
3
4
    location ~ ^/(cron|templates)/ {
    deny all;
    break;
    }

禁止以/data开头的文件
可以禁止/data/下多级目录下.log.txt等请求;

Shell
1
2
3
    location ~ ^/data {
    deny all;
    }

禁止单个目录
不能禁止.log.txt能请求

Shell
1
2
3
    location /searchword/cron/ {
    deny all;
    }

禁止单个文件

Shell
1
2
3
    location ~ /data/sql/data.sql {
    deny all;
    }

给favicon.ico和robots.txt设置过期时间;
这里为favicon.ico为99天,robots.txt为7天并不记录404错误日志

Shell
1
2
3
4
5
6
7
8
9
10
    location ~(favicon.ico) {
    log_not_found off;
    expires 99d;
    break;
    }
    location ~(robots.txt) {
    log_not_found off;
    expires 7d;
    break;
    }

设定某个文件的过期时间;这里为600秒，并不记录访问日志

Shell
1
2
3
4
5
6
    location ^~ /html/scripts/loadhead_1.js {
    access_log   off;
    root /opt/lampp/htdocs/web;
    expires 600;
    break;
    }

文件反盗链并设置过期时间

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
这里的return 412 为自定义的http状态码，默认为403，方便找出正确的盗链的请求
“rewrite ^/ http://leech.c1gstudio.com/leech.gif;”显示一张防盗链图片
“access_log off;”不记录访问日志，减轻压力
“expires 3d”所有文件3天的浏览器缓存
 
    location ~* ^.+\.(jpg|jpeg|gif|png|swf|rar|zip|css|js)$ {
    valid_referers none blocked *.c1gstudio.com *.c1gstudio.net localhost 208.97.167.194;
    if ($invalid_referer) {
    rewrite ^/ http://leech.c1gstudio.com/leech.gif;
    return 412;
    break;
    }
    access_log   off;
    root /opt/lampp/htdocs/web;
    expires 3d;
    break;
    }

只充许固定ip访问网站，并加上密码

Shell
1
2
3
4
5
6
7
    root  /opt/htdocs/www;
    allow   208.97.167.194;
    allow   222.33.1.2;
    allow   231.152.49.4;
    deny    all;
    auth_basic "C1G_ADMIN";
    auth_basic_user_file htpasswd;

将多级目录下的文件转成一个文件，增强seo效果
/job-123-456-789.html 指向/job/123/456/789.html

Shell
1
    rewrite ^/job-([0-9]+)-([0-9]+)-([0-9]+)\.html$ /job/$1/$2/jobshow_$3.html last;

将根目录下某个文件夹指向2级目录
如/shanghaijob/ 指向 /area/shanghai/
如果你将last改成permanent，那么浏览器地址栏显是/location/shanghai/

Shell
1
rewrite ^/([0-9a-z]+)job/(.*)$ /area/$1/$2 last;

上面例子有个问题是访问/shanghai 时将不会匹配

Shell
1
2
    rewrite ^/([0-9a-z]+)job$ /area/$1/ last;
    rewrite ^/([0-9a-z]+)job/(.*)$ /area/$1/$2 last;

这样/shanghai 也可以访问了，但页面中的相对链接无法使用，
如./list_1.html真实地址是/area/shanghia/list_1.html会变成/list_1.html,导至无法访问。

那我加上自动跳转也是不行咯
(-d $request_filename)它有个条件是必需为真实目录，而我的rewrite不是的，所以没有效果

Shell
1
2
3
    if (-d $request_filename){
    rewrite ^/(.*)([^/])$ http://$host/$1$2/ permanent;
    }

知道原因后就好办了，让我手动跳转吧

Shell
1
2
    rewrite ^/([0-9a-z]+)job$ /$1job/ permanent;
    rewrite ^/([0-9a-z]+)job/(.*)$ /area/$1/$2 last;

文件和目录不存在的时候重定向：

Shell
1
2
3
    if (!-e $request_filename) {
    proxy_pass http://127.0.0.1;
    }

域名跳转

Shell
1
2
3
4
5
6
7
8
9
server
{
    listen       80;
    server_name  jump.c1gstudio.com;
    index index.html index.htm index.php;
    root  /opt/lampp/htdocs/www;
    rewrite ^/ http://www.c1gstudio.com/;
    access_log  off;
}

多域名转向

Shell
1
2
3
4
5
6
    server_name  www.c1gstudio.com www.c1gstudio.net;
    index index.html index.htm index.php;
    root  /opt/lampp/htdocs;
    if ($host ~ "c1gstudio\.net") {
    rewrite ^(.*) http://www.c1gstudio.com$1 permanent;
    }

三级域名跳转

Shell
1
2
3
4
    if ($http_host ~* "^(.*)\.i\.c1gstudio\.com$") {
    rewrite ^(.*) http://top.yingjiesheng.com$1;
    break;
    }

域名镜向

Shell
1
2
3
4
5
6
7
8
9
server
{
    listen       80;
    server_name  mirror.c1gstudio.com;
    index index.html index.htm index.php;
    root  /opt/lampp/htdocs/www;
    rewrite ^/(.*) http://www.c1gstudio.com/$1 last;
    access_log  off;
}

某个子目录作镜向

Shell
1
2
3
4
    location ^~ /zhaopinhui {
    rewrite ^.+ http://zph.c1gstudio.com/ last;
    break;
    }

discuz ucenter home (uchome) rewrite

Shell
1
2
3
    rewrite ^/(space|network)-(.+)\.html$ /$1.php?rewrite=$2 last;
    rewrite ^/(space|network)\.html$ /$1.php last;
    rewrite ^/([0-9]+)$ /space.php?uid=$1 last;

discuz 7 rewrite

Shell
1
2
3
4
5
6
    rewrite ^(.*)/archiver/((fid|tid)-[\w\-]+\.html)$ $1/archiver/index.php?$2 last;
    rewrite ^(.*)/forum-([0-9]+)-([0-9]+)\.html$ $1/forumdisplay.php?fid=$2&page=$3 last;
    rewrite ^(.*)/thread-([0-9]+)-([0-9]+)-([0-9]+)\.html$ $1/viewthread.php?tid=$2&extra=page\%3D$4&page=$3 last;
    rewrite ^(.*)/profile-(username|uid)-(.+)\.html$ $1/viewpro.php?$2=$3 last;
    rewrite ^(.*)/space-(username|uid)-(.+)\.html$ $1/space.php?$2=$3 last;
    rewrite ^(.*)/tag-(.+)\.html$ $1/tag.php?name=$2 last;

给discuz某版块单独配置域名

Shell
1
2
3
4
5
6
7
8
9
server_name  bbs.c1gstudio.com news.c1gstudio.com;
location = /
{
    if ($http_host ~ news\.c1gstudio.com$)
    {
    rewrite ^.+ http://news.c1gstudio.com/forum-831-1.html last;
    break;
    }
}

discuz ucenter 头像 rewrite 优化

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    location ^~ /ucenter {
    location ~ .*\.php?$
    {
    #fastcgi_pass  unix:/tmp/php-cgi.sock;
    fastcgi_pass  127.0.0.1:9000;
    fastcgi_index index.php;
    include fcgi.conf;
    }
    location /ucenter/data/avatar {
    log_not_found off;
    access_log   off;
    location ~ /(.*)_big\.jpg$ {
    error_page 404 /ucenter/images/noavatar_big.gif;
    }
    location ~ /(.*)_middle\.jpg$ {
    error_page 404 /ucenter/images/noavatar_middle.gif;
    }
    location ~ /(.*)_small\.jpg$ {
    error_page 404 /ucenter/images/noavatar_small.gif;
    }
    expires 300;
    break;
    }
    }

jspace rewrite

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
    location ~ .*\.php?$
    {
    #fastcgi_pass  unix:/tmp/php-cgi.sock;
    fastcgi_pass  127.0.0.1:9000;
    fastcgi_index index.php;
    include fcgi.conf;
    }
    location ~* ^/index.php/
    {
    rewrite ^/index.php/(.*) /index.php?$1 break;
    fastcgi_pass  127.0.0.1:9000;
    fastcgi_index index.php;
    include fcgi.conf;
    }

wordpress rewrite

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
    location / {
    index index.html index.php;
    if (-f $request_filename/index.html){
    rewrite (.*) $1/index.html break;
    }
    if (-f $request_filename/index.php){
    rewrite (.*) $1/index.php;
    }
    if  (!-e $request_filename)
    {
    rewrite (.*) /index.php;
    }
    }

VC++七种延时方式

第七根弦 2014 年 3 月 15 日 未分类 0

方式一：VC中的WM_TIMER消息映射能进行简单的时间控制。首先调用函数SetTimer()设置定时间隔，如SetTimer(0,200,NULL)即为设置200ms的时间间隔。然后在应用程序中增加定时响应函数OnTimer()，并在该函数中添加响应的处理语句，用来完成到达定时时间的操作。这种定时方法非常简单，可以实现一定的定时功能，但其定时功能如同Sleep()函数的延时功能一样，精度非常低，最小计时精度仅为30ms，CPU占用低，且定时器消息在多任务操作系统中的优先级很低，不能得到及时响应，往往不能满足实时控制环境下的应用。只可以用来实现诸如位图的动态显示等对定时精度要求不高的情况。如示例工程中的Timer1。 　　

方式二：VC中使用sleep()函数实现延时，它的单位是ms，如延时2秒，用sleep(2000)。精度非常低，最小计时精度仅为30ms，用sleep函数的不利处在于延时期间不能处理其他的消息，如果时间太长，就好象死机一样，CPU占用率非常高，只能用于要求不高的延时程序中。如示例工程中的Timer2。 　　

方式三：利用COleDateTime类和COleDateTimeSpan类结合WINDOWS的消息处理过程来实现秒级延时。如示例工程中的Timer3和Timer3_1。以下是实现2秒的延时代码：

C++
1
2
3
COleDateTimestart_time = COleDateTime::GetCurrentTime();
COleDateTimeSpanend_time = COleDateTime::GetCurrentTime() - start_time;
while(end_time.GetTotalSeconds())

　

方式四：在精度要求较高的情况下，VC中可以利用GetTickCount()函数，该函数的返回值是DWORD型，表示以ms为单位的计算机启动后经历的时间间隔。精度比WM_TIMER消息映射高，在较短的定时中其计时误差为15ms，在较长的定时中其计时误差较低，如果定时时间太长，就好象死机一样，CPU占用率非常高，只能用于要求不高的延时程序中。如示例工程中的Timer4和Timer4_1。下列代码可以实现50ms的精确定时： 　　

C++
1
2
3
4
5
6
DWORDdwStart = GetTickCount(); 　　
DWORDdwEnd = dwStart; 　　
do 　　
{ 　　
    dwEnd = GetTickCount() - dwStart;
}while(dwEnd)

为使GetTickCount()函数在延时或定时期间能处理其他的消息，可以把代码改为：

C++
1
2
3
4
5
6
7
8
9
10
DWORDdwStart=GetTickCount();
DWORDdwEnd=dwStart;
do
{
    MSGmsg;
    GetMessage(msg,NULL,0,0);
    TranslateMessage(msg);
    DispatchMessage(msg);
    dwEnd=GetTickCount() - dwStart;
}while(dwEnd)

　　

虽然这样可以降低CPU的占有率，并在延时或定时期间也能处理其他的消息，但降低了延时或定时精度。 　　

方式五：与GetTickCount()函数类似的多媒体定时器函数DWORDtimeGetTime(void)，该函数定时精度为ms级，返回从Windows启动开始经过的毫秒数。微软公司在其多媒体Windows中提供了精确定时器的底层API持，利用多媒体定时器可以很精确地读出系统的当前时间，并且能在非常精确的时间间隔内完成一个事件、函数或过程的调用。不同之处在于调用DWORDtimeGetTime(void)函数之前必须将Winmm.lib和Mmsystem.h添加到工程中，否则在编译时提示DWORDtimeGetTime(void)函数未定义。由于使用该函数是通过查询的方式进行定时控制的，所以，应该建立定时循环来进行定时事件的控制。如示例工程中的Timer5和Timer5_1。 　　

方式六：使用多媒体定时器timeSetEvent()函数，该函数定时精度为ms级。利用该函数可以实现周期性的函数调用。如示例工程中的Timer6和Timer6_1。函数的原型如下：

C++
1
MMRESULTtimeSetEvent（UINTuDelay, UINTuResolution, PTIMECALLBACKlpTimeProc, WORDdwUser, UINTfuEvent)

该函数设置一个定时回调事件，此事件可以是一个一次性事件或周期性事件。事件一旦被激活，便调用指定的回调函数，成功后返回事件的标识符代码，否则返回NULL。函数的参数说明如下： 　　
uDelay：以毫秒指定事件的周期。 　　
Uresolution：以毫秒指定延时的精度，数值越小定时器事件分辨率越高。缺省值为1ms。
LpTimeProc：指向一个回调函数。 　　
DwUser：存放用户提供的回调数据。 　　
FuEvent：指定定时器事件类型： 　　
TIME_ONESHOT：uDelay毫秒后只产生一次事件 　　
TIME_PERIODIC：每隔uDelay毫秒周期性地产生事件。 　　

具体应用时，可以通过调用timeSetEvent()函数，将需要周期性执行的任务定义在LpTimeProc回调函数中(如：定时采样、控制等)，从而完成所需处理的事件。需要注意的是，任务处理的时间不能大于周期间隔时间。另外，在定时器使用完毕后，应及时调用timeKillEvent()将之释放。 　　

方式七：对于精确度要求更高的定时操作，则应该使用QueryPerformanceFrequency()和QueryPerformanceCounter()函数。这两个函数是VC提供的仅供Windows95及其后续版本使用的精确时间函数，并要求计算机从硬件上支持精确定时器。如示例工程中的Timer7、Timer7_1、Timer7_2、Timer7_3。 　　
QueryPerformanceFrequency()函数和QueryPerformanceCounter()函数的原型如下： 　　
BOOLQueryPerformanceFrequency(LARGE_INTEGER＊lpFrequency); 　　 BOOLQueryPerformanceCounter(LARGE_INTEGER＊lpCount); 　　
数据类型ARGE_INTEGER既可以是一个8字节长的整型数，也可以是两个4字节长的整型数的联合结构，其具体用法根据编译器是否支持64位而定。该类型的定义如下：

C++
1
2
3
4
5
6
7
8
9
typedefunion_LARGE_INTEGER
{
    struct
    { 　　
        DWORDLowPart; 　　 　　 　　//4字节整型数
        LONGHighPart; 　　 　　 　　//4字节整型数
    };
    LONGLONGQuadPart; 　　 　　 　　//8字节整型数
}LARGE_INTEGER;

在进行定时之前，先调用QueryPerformanceFrequency()函数获得机器内部定时器的时钟频率，然后在需要严格定时的事件发生之前和发生之后分别调用QueryPerformanceCounter()函数，利用两次获得的计数之差及时钟频率，计算出事件经历的精确时间。
下列代码实现1ms的精确定时： 　　

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
LARGE_INTEGERlitmp;
LONGLONGQPart1,QPart2;
doubledfMinus,dfFreq,dfTim;
QueryPerformanceFrequency(&litmp);
dfFreq=(double)litmp.QuadPart; 　　 　　//获得计数器的时钟频率
QueryPerformanceCounter(&litmp);
QPart1=litmp.QuadPart; 　　 　　 　　//获得初始值
do 　　
{
    QueryPerformanceCounter(&litmp);
    QPart2=litmp.QuadPart; 　　 　　//获得中止值
    dfMinus=(double)(QPart2-QPart1);
    dfTim=dfMinus/dfFreq; 　　 　　//获得对应的时间值，单位为秒 　　
}while(dfTim) 　　

其定时误差不超过1微秒，精度与CPU等机器配置有关。
下面的程序用来测试函数Sleep(100)的精确持续时间：

C++
1
2
3
4
5
6
7
8
9
10
11
12
LARGE_INTEGERlitmp;
LONGLONGQPart1,QPart2;
doubledfMinus,dfFreq,dfTim;
QueryPerformanceFrequency(&litmp);
dfFreq=(double)litmp.QuadPart; 　　 　　 　　//获得计数器的时钟频率
QueryPerformanceCounter(&litmp);
QPart1=litmp.QuadPart; 　　 　　//获得初始值 　　
Sleep(100);
QueryPerformanceCounter(&litmp);
QPart2=litmp.QuadPart; 　　 　　//获得中止值 　　
dfMinus=(double)(QPart2-QPart1);
dfTim=dfMinus/dfFreq; 　　 　　//获得对应的时间值，单位为秒

由于Sleep()函数自身的误差，上述程序每次执行的结果都会有微小误差。
下列代码实现1微秒的精确定时：

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
LARGE_INTEGERlitmp;
LONGLONGQPart1,QPart2;
doubledfMinus,dfFreq,dfTim;
QueryPerformanceFrequency(&litmp);
dfFreq=(double)litmp.QuadPart; 　　 　　 　　//获得计数器的时钟频率
QueryPerformanceCounter(&litmp);
QPart1=litmp.QuadPart; 　　 　　 　　//获得初始值
do
{
    QueryPerformanceCounter(&litmp);
    QPart2=litmp.QuadPart; 　　 　　//获得中止值
    dfMinus=(double)(QPart2-QPart1);
    dfTim=dfMinus/dfFreq; 　　 　　//获得对应的时间值，单位为秒 　　
}while(dfTim)

其定时误差一般不超过0.5微秒，精度与CPU等机器配置有关。

Linux服务器下配置exif功能

第七根弦 2014 年 3 月 14 日 未分类 0

DZ程序中支持图片附件显示 EXIF
信息，但是我们的服务器一般都不支持此功能，现在就简单介绍一下如果在LINUX服务器上配置exif功能，最后提供一个exif压缩包的下载地址(如果你服务器上没有这个文件的话可以下载使用)

先找一下LINUX服务器上php的安装目录，例如为：/root/lnmp0.4-full/php-5.2.10/

则执行：

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
cd /root/lnmp0.4-full/php-5.2.10/ext/
 
我们要安装exif模块，执行
 
cd exif/
 
再执行
 
/usr/local/php/bin/phpize 会返回如下信息：
 
Configuring for:
 
PHP Api Version: 20041225
 
Zend Module Api No: 20060613
 
Zend Extension Api No: 220060519
 
再执行以下命令：
 
[root@vpser imap]# ./configure
-with-php-config=/usr/local/php/bin/php-config
 
[root@vpser imap]# make && make install
 
执行完返回：
 
Build complete.
 
Don't forget to run 'make test'.
 
Installing shared extensions:
/usr/local/php/lib/php/extensions/no-debug-non-zts-20060613/
 
表示已经成功，再修改
 
/usr/local/php/etc/php.ini
 
查找：extension = 再最后一个extension= 后面添加上extension = "exif.so"
 
保存，执行/root/lnmp restart 重启。

C++ 发送邮件（C++源码）

第七根弦 2014 年 3 月 12 日 未分类 0

 

 

 

效果

001

这里是类的代码 CSendMail .h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
*************************************************************************/  
#pragma once  
struct sMailInfo //邮件信息  
{  
    char*   m_pcUserName;//用户登录邮箱的名称  
    char*   m_pcUserPassWord;//用户登录邮箱的密码  
    char*   m_pcSenderName;//用户发送时显示的名称  
    char*   m_pcSender;//发送者的邮箱地址  
    char*   m_pcReceiver;//接收者的邮箱地址  
    char*   m_pcTitle;//邮箱标题  
    char*   m_pcBody;//邮件文本正文  
    char*   m_pcIPAddr;//服务器的IP  
    char*   m_pcIPName;//服务器的名称（IP与名称二选一，优先取名称）  
    sMailInfo(){memset(this,0,sizeof(sMailInfo));}  
};  
class CSendMail  
{  
public:  
    CSendMail(void);  
    ~CSendMail(void);  
  
public:  
    bool SendMail(sMailInfo &smailInfo);//发送邮件，需要在发送的时候初始化邮件信息  
    void AddFilePath(char * pcFilePath);//添加附件的决定路径到附件列表中  
    void DeleteFilePath(char* pcFilePath);//删除附件路径，如果有的话  
    void DeleteAllPath(void);//删除全部附件的路径  
  
protected:  
    void GetFileName(char* fileName,char* filePath);//从附件的路径中获取文件名称  
    void Char2Base64(char* pBuff64,char* pSrcBuff,int iLen);//把char类型转换成Base64类型  
    bool  CReateSocket(SOCKET &sock);//建立socket连接  
    bool Logon(SOCKET &sock);//登录邮箱，主要进行发邮件前的准备工作  
    int GetFileData(char* FilePath);//由文件路径获取附件内容  
  
    bool SendHead(SOCKET &sock);//发送邮件头  
    bool SendTextBody(SOCKET &sock);//发送邮件文本正文  
    bool SendFileBody(SOCKET &sock);//发送邮件附件  
    bool SendEnd(SOCKET &sock);//发送邮件结尾  
protected:  
    CList<char*,char*> m_pcFilePathList;//记录附件路径  
  
    char  m_cSendBuff[4096];//发送缓冲区  
    char  m_cReceiveBuff[1024];  
    char* m_pcFileBuff;//指向附件内容  
    sMailInfo m_sMailInfo;  
};  

CSendMail.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
/************************************************************************
* 发送邮件模块
*可以发送文本和附件（支持多个附件一起发送）
*Date:2011-12-01
************************************************************************/  
#include "StdAfx.h"  
#include "CSendMail.h"  
#include "winsock2.h"  
#pragma comment(lib,"WSOCK32")  
#pragma comment(lib, "ws2_32")
 
CSendMail::CSendMail(void)  
{  
    m_pcFileBuff=NULL;  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    memset(m_cReceiveBuff,0,sizeof(m_cReceiveBuff));  
}  
  
  
CSendMail::~CSendMail(void)  
{  
    DeleteAllPath();  
}  
  
  
void CSendMail::Char2Base64(char* pBuff64,char* pSrcBuff,int iLen)  
{  
    //1   1   1   1   1   1   1   1  
    // 分配给pBuff64  ↑ 分配给pBuff64+1  
    //         point所在的位置  
    static char Base64Encode[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";//base64所映射的字符表  
    int point;//每一个源字符拆分的位置，可取2,4,6；初始为2  
    point=2;  
    int i;  
    int iIndex;//base64字符的索引  
    char n=0;//上一个源字符的残留值  
    for(i=0;i<iLen;i++)  
    {  
        if(point==2)  
        {  
            iIndex=((*pSrcBuff)>>point)&0x3f;//取得pSrcBuff的高point位  
        }  
        else if (point==4)  
        {  
            iIndex=((*pSrcBuff)>>point)&0xf;//取得pSrcBuff的高point位  
        }  
        else if(point==6)  
        {  
            iIndex=((*pSrcBuff)>>point)&0x3;//取得pSrcBuff的高point位  
        }  
        iIndex+=n;//与pSrcBuff-1的低point结合组成Base64的索引  
        *pBuff64++=Base64Encode[iIndex];//由索引表得到pBuff64  
        n=((*pSrcBuff)<<(6-point));//计算源字符中的残留值  
        n=n&0x3f;//确保n的最高两位为0  
        point+=2;//源字符的拆分位置上升2  
        if(point==8)//如果拆分位置为8说明pSrcBuff有6位残留，可以组成一个完整的Base64字符，所以直接再组合一次  
        {  
            iIndex=(*pSrcBuff)&0x3f;//提取低6位，这就是索引了  
            *pBuff64++=Base64Encode[iIndex];//  
            n=0;//残留值为0  
            point=2;//拆分位置设为2  
        }  
        pSrcBuff++;  
  
    }  
    if(n!=0)  
    {  
        *pBuff64++=Base64Encode[n];  
    }  
    if(iLen%3==2)//如果源字符串长度不是3的倍数要用'='补全  
    {  
        *pBuff64='=';  
    }  
    else if(iLen%3==1)  
    {  
        *pBuff64++='=';  
        *pBuff64='=';  
    }  
}  
  
void CSendMail::AddFilePath(char * pcFilePath)//添加附件路径  
{  
    if(pcFilePath==NULL)  
    {  
        return;  
    }  
    int i;  
    char* temp;  
    for(i=0;i<m_pcFilePathList.GetCount();i++)  
    {  
        temp=m_pcFilePathList.GetAt(m_pcFilePathList.FindIndex(i));  
        if(strcmp(pcFilePath,temp)==0)//如果已经存在就不用再添加了  
        {  
            return;  
        }  
    }  
    m_pcFilePathList.AddTail(pcFilePath);  
}  
  
void CSendMail::DeleteFilePath(char* pcFilePath)//删除附件路径  
{  
    int i;  
    char* temp;  
    for(i=0;i<m_pcFilePathList.GetCount();i++)  
    {  
        temp=m_pcFilePathList.GetAt(m_pcFilePathList.FindIndex(i));  
        if(strcmp(temp,pcFilePath)==0)//找到并删除它，如果没找到就算了  
        {  
            m_pcFilePathList.RemoveAt(m_pcFilePathList.FindIndex(i));  
            delete[] temp;  
            return;  
        }  
    }  
}  
  
  
void CSendMail::DeleteAllPath(void)  
{  
    m_pcFilePathList.RemoveAll();  
}  
  
int CSendMail::GetFileData(char* FilePath)  
{  
    m_pcFileBuff=NULL;  
    if(FilePath==NULL)  
    {  
        return 0;  
    }  
    CFile f;  
    int len;  
      
      
    USES_CONVERSION;  
    if(!f.Open(A2W(FilePath),CFile::modeRead|CFile::modeNoTruncate|CFile::typeBinary))  
    {  
        return 0;  
    }  
    len=(int)f.GetLength();  
    m_pcFileBuff=new char[len+1];  
    memset(m_pcFileBuff,0,len+1);  
    f.Read(m_pcFileBuff,len);  
  
    f.Close();  
    return len;  
}  
  
void CSendMail::GetFileName(char* fileName,char* filePath)  
{  
    if(filePath==NULL || fileName==NULL)  
    {  
        return;  
    }  
    int i;  
    for(i=0;i<(int)strlen(filePath);i++)  
    {  
        if(filePath[strlen(filePath)-1-i]=='\\')  
        {  
            memcpy(fileName,&filePath[strlen(filePath)-i],i);  
            return;  
        }  
    }  
}  
  
bool CSendMail::CReateSocket(SOCKET &sock)  
{  
    WORD wVersionRequested;  
    WSADATA wsaData;  
    int err;  
    wVersionRequested = MAKEWORD( 2, 2 );  
    err = WSAStartup( wVersionRequested, &wsaData );  
    if ( err != 0 )  
    {  
        return false;  
    }  
    if ( LOBYTE( wsaData.wVersion ) != 2 ||  
        HIBYTE( wsaData.wVersion ) != 2 )  
    {  
        WSACleanup( );  
        return false;  
    }  
    sock = socket(AF_INET,SOCK_STREAM,IPPROTO_IP);  
    if (sock == INVALID_SOCKET)  
    {  
        return false;  
    }  
  
    sockaddr_in servaddr;  
    memset(&servaddr,0,sizeof(sockaddr_in));  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_port = htons(25);//发邮件一般都是25端口  
    if(m_sMailInfo.m_pcIPName=="")  
    {  
        servaddr.sin_addr.s_addr = inet_addr(m_sMailInfo.m_pcIPAddr);//直接使用IP地址  
    }  
    else  
    {  
        struct hostent *hp=gethostbyname(m_sMailInfo.m_pcIPName);//使用名称  
if (hp == NULL)
{
DWORD dwErrCode = GetLastError();
return false;
}
        servaddr.sin_addr.s_addr=*(int*)(*hp->h_addr_list);  
    }  
  
  
    int ret = connect(sock,(sockaddr*)&servaddr,sizeof(servaddr));//建立连接  
    if (ret == SOCKET_ERROR)  
    {  
DWORD dwErr = GetLastError();
        return false;  
    }  
  
    return true;  
}  
  
  
bool CSendMail::Logon(SOCKET &sock)  
{  
    recv(sock,m_cReceiveBuff,1024,0);  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"HELO []\r\n");  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);//开始会话  
    recv(sock,m_cReceiveBuff,1024,0);  
    if(m_cReceiveBuff[0]!='2' || m_cReceiveBuff[1]!='5' || m_cReceiveBuff[2]!='0')  
    {  
        return false;  
    }  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"AUTH LOGIN\r\n");  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);//请求登录  
    recv(sock,m_cReceiveBuff,1024,0);  
    if(m_cReceiveBuff[0]!='3' || m_cReceiveBuff[1]!='3' || m_cReceiveBuff[2]!='4')  
    {  
        return false;  
    }  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    Char2Base64(m_cSendBuff,m_sMailInfo.m_pcUserName,strlen(m_sMailInfo.m_pcUserName));  
    m_cSendBuff[strlen(m_cSendBuff)]='\r';  
    m_cSendBuff[strlen(m_cSendBuff)]='\n';  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);//发送用户名  
    recv(sock,m_cReceiveBuff,1024,0);  
    if(m_cReceiveBuff[0]!='3' || m_cReceiveBuff[1]!='3' || m_cReceiveBuff[2]!='4')  
    {  
        return false;  
    }  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    Char2Base64(m_cSendBuff,m_sMailInfo.m_pcUserPassWord,strlen(m_sMailInfo.m_pcUserPassWord));  
    m_cSendBuff[strlen(m_cSendBuff)]='\r';  
    m_cSendBuff[strlen(m_cSendBuff)]='\n';  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);//发送用户密码  
    recv(sock,m_cReceiveBuff,1024,0);  
    if(m_cReceiveBuff[0]!='2' || m_cReceiveBuff[1]!='3' || m_cReceiveBuff[2]!='5')  
    {  
        return false;  
    }  
    return true;//登录成功  
}  
  
  
bool CSendMail::SendHead(SOCKET &sock)  
{  
    int rt;  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"MAIL FROM:<%s>\r\n",m_sMailInfo.m_pcSender);  
    rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
      
    if(rt!=strlen(m_cSendBuff))  
    {  
        return false;  
    }  
    recv(sock,m_cReceiveBuff,1024,0);  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"RCPT TO:<%s>\r\n",m_sMailInfo.m_pcReceiver);  
    rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
    if(rt!=strlen(m_cSendBuff))  
    {  
        return false;  
    }  
    recv(sock,m_cReceiveBuff,1024,0);  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    memcpy(m_cSendBuff,"DATA\r\n",strlen("DATA\r\n"));  
    rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
    if(rt!=strlen(m_cSendBuff))  
    {  
        return false;  
    }  
    recv(sock,m_cReceiveBuff,1024,0);  
  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"From:\"%s\"<%s>\r\n",m_sMailInfo.m_pcSenderName,m_sMailInfo.m_pcSender);  
    sprintf_s(&m_cSendBuff[strlen(m_cSendBuff)],150,"To:\"INVT.COM.CN\"<%s>\r\n",m_sMailInfo.m_pcReceiver);  
    sprintf_s(&m_cSendBuff[strlen(m_cSendBuff)],150,"Subject:%s\r\nMime-Version: 1.0\r\nContent-Type: multipart/mixed;   boundary=\"INVT\"\r\n\r\n",m_sMailInfo.m_pcTitle);  
    rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
    if(rt!=strlen(m_cSendBuff))  
    {  
        return false;  
    }  
  
    return true;  
}  
  
bool CSendMail::SendTextBody(SOCKET &sock)  
{  
    int rt;  
    memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
    sprintf_s(m_cSendBuff,"--INVT\r\nContent-Type: text/plain;\r\n  charset=\"gb2312\"\r\n\r\n%s\r\n\r\n",m_sMailInfo.m_pcBody);  
    rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
    if(rt!=strlen(m_cSendBuff))  
    {  
        return false;  
    }  
    else  
    {  
        return true;  
    }  
}  
  
bool CSendMail::SendFileBody(SOCKET &sock)  
{  
    int i;  
    char* filePath;  
    int rt;  
    int len;  
    int pt=0;  
    char fileName[128];  
    for(i=0;i<m_pcFilePathList.GetCount();i++)  
    {  
        pt=0;  
        memset(fileName,0,128);  
        filePath=m_pcFilePathList.GetAt(m_pcFilePathList.FindIndex(i));  
        len=GetFileData(filePath);  
        GetFileName(fileName,filePath);  
  
        sprintf_s(m_cSendBuff,"--INVT\r\nContent-Type: application/octet-stream;\r\n  name=\"%s\"\r\nContent-Transfer-Encoding: base64\r\nContent-Disposition: attachment;\r\n  filename=\"%s\"\r\n\r\n",fileName,fileName);  
        send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
        while (pt<len)  
        {  
            memset(m_cSendBuff,0,sizeof(m_cSendBuff));  
            Char2Base64(m_cSendBuff,&m_pcFileBuff[pt],min(len-pt,3000));  
            m_cSendBuff[strlen(m_cSendBuff)]='\r';  
            m_cSendBuff[strlen(m_cSendBuff)]='\n';  
            rt=send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
            pt+=min(len-pt,3000);  
            if(rt!=strlen(m_cSendBuff))  
            {  
                return false;  
            }  
        }  
        if(len!=0)  
        {  
            delete [] m_pcFileBuff;  
        }  
    }  
  
    return true;  
}  
  
bool CSendMail::SendEnd(SOCKET &sock)  
{  
    sprintf_s(m_cSendBuff,"--INVT--\r\n.\r\n");  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
  
    sprintf_s(m_cSendBuff,"QUIT\r\n");  
    send(sock,m_cSendBuff,strlen(m_cSendBuff),0);  
    closesocket(sock);  
    WSACleanup();  
    return true;  
}  
  
  
bool CSendMail::SendMail(sMailInfo &smailInfo)  
{  
    memcpy(&m_sMailInfo,&smailInfo,sizeof(smailInfo));  
    if(m_sMailInfo.m_pcBody==NULL  
        || m_sMailInfo.m_pcIPAddr==NULL  
        || m_sMailInfo.m_pcIPName==NULL  
        || m_sMailInfo.m_pcReceiver==NULL  
        || m_sMailInfo.m_pcSender==NULL  
        || m_sMailInfo.m_pcSenderName==NULL  
        || m_sMailInfo.m_pcTitle==NULL  
        || m_sMailInfo.m_pcUserName==NULL  
        || m_sMailInfo.m_pcUserPassWord==NULL)  
    {  
        return false;  
    }  
    SOCKET sock;  
    if(!CReateSocket(sock))//建立连接  
    {  
        return false;  
    }  
  
    if(!Logon(sock))//登录邮箱  
    {  
        return false;  
    }  
  
    if(!SendHead(sock))//发送邮件头  
    {  
        return false;  
    }  
  
    if(!SendTextBody(sock))//发送邮件文本部分  
    {  
        return false;  
    }  
  
    if(!SendFileBody(sock))//发送附件  
    {  
        return false;  
    }  
  
    if(!SendEnd(sock))//结束邮件，并关闭sock  
    {  
        return false;  
    }  
  
    return true;  
}  

测试代码

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "CSendMail/CSendMail.h"
void testMail2()
{
sMailInfo sm;
sm.m_pcUserName = "这里是QQ号码";//"";
sm.m_pcUserPassWord ="这里是QQ密码";// "";
sm.m_pcSenderName = "爱说话的汤姆猫";
sm.m_pcSender = "[email protected]";//发送者的邮箱地址  
sm.m_pcReceiver = "[email protected]";//接收者的邮箱地址  
sm.m_pcTitle = "测试垃圾邮件";//邮箱标题  
sm.m_pcBody = "你想快速发家致富吗？你想一夜成名吗？访问 http://www.sb.com";//邮件文本正文  
sm.m_pcIPAddr = "" ;//服务器的IP可以留空
sm.m_pcIPName ="smtp.qq.com" ;//服务器的名称（IP与名称二选一，优先取名称）  
 
CSendMail csm;
while(TRUE)
{
csm.SendMail(sm);
Sleep(1000 * 20);
}
}

代码说明:
SMailer 是网上流传最广泛的一个C++发送邮件的类。但是我在测试的时候并没有发送成功。没有找出原因在哪里。
CSendMail　是在CSDN上找到的一个发送邮件的类。经测试可用。
我写了一个测试的工程
TestEMail

对virtualbox虚拟机进行网络配置，实现内网外网互通！桥接！

第七根弦 2014 年 3 月 12 日 未分类 0

实验环境如下：
virtualbox上运行的虚拟机：windows 2008 en
实体机IP：192.168.18.99 内网段：192.168.18.X
实体机：Red Hat Enterprise Linux Server release 5 (Tikanga)

virtualbox主要有下面几种方式（不同版本称法不一样，但实质是一样的）：
1、Intelnal Network：利用主机上的所有的虚拟机构建一个虚拟网络
2、NAT：能访问互联网，不能访问主机（或局域网）
3、Host Interface：能访问主机（或局域网），不能访问互联网

本教程运用NAT＋interface的方法。
首先打开virtualbox>设置>网络，启用网络连接，并按如下配置。

001

这里点确定，并运行虚拟机，本机系统会自动创建一个名为vboxnet0的虚拟网卡

002

IP为：192.168.56.1
进入虚拟机系统（本人安装的是winvows 2008 en）,将网卡的IP设置为vboxnet0的虚拟网卡同网段IP，ouyaoxiazai.com，网关为vboxnet0的IP，192.168.56.1

003

这里你会发现可以ping 192.168.56.1 但无法连接到局域网。
这时回到实体机，
系统＞管理＞网络，打开网络配置＞设备，双击当前设备，设置路由如下：

004

然后保存退出，打开终端，重启下网卡：
/etc/rc.d/init.d/network restart
这时你就可以正常访问内网了，但无法访问互联网，就是不能上网。
接下来进行NAT，很简单，先关闭虚拟机系统。
和上面一样，设置，网络。
选择网络连接2，启用NAT，如图：

005

然后启动系统，你会发现多了一块网卡，自动获取IP如下：

006

现在应该可以正常上网了，并能访问内网了。。。。

007