404频道

学习笔记

Posted on Edited on

最近在看《Linux/Unix系统编程手册》一书，这里对书中提到的函数类型进行总结。

可重入

POSIX标准中的解释如下：

Reentrant Function:
A function whose effect, when called by two or more threads,is guaranteed to be as if the threads each executed thefunction one after another in an undefined order, even ifthe actual execution is interleaved.

可重入函数跟信号相关，一种更容易理解的解释为：

程序执行到某个函数foo()时，收到信号，于是暂停目前正在执行的函数，转到信号处理函数，而这个信号处理函数的执行过程中，又恰恰也会进入到刚刚执行的函数foo()，便发生了所谓的重入。此时如果foo()能够正确的运行，而且处理完成后，之前暂停的foo()也能够正确运行，则说明它是可重入的。

可重入函数需要满足如下几个条件：

  • 不在函数内部使用静态或全局数据
  • 不返回静态或全局数据，所有数据均有函数调用者提供
  • 使用本地数据或通过复制全局数据来保护全局数据
  • 不调用不可重入函数

标准的异步安全信号函数

异步信号安全的函数指当从信号处理函数调用时，可保证实现是安全的。如果某一个函数是可重入的，或者信号处理函数无法将其中断时，称该函数是异步信号安全的。

我的理解是可重入函数和标准的异步安全信号函数基本等同，只是描述层面不同。

线程安全

若函数可同时供多个线程安全的调用，则该函数为线程安全的函数。比较容易理解。

线程安全与可重入之间的关系

可重入函数一定为线程安全的函数。线程安全函数不一定是可重入函数。

不可重入函数，函数调用结果不具有可再现性，可通过互斥锁等机制供多个线程安全的调用，这样该不可重入函数即为线程安全的函数。

malloc函数内部维护了全局数据结构，因此为不可重入的，但是内部通过递归互斥量来确保为线程安全的函数。并且该互斥量必须是可递归的，否则当malloc函数重入的情况下，会造成死锁。在glibc中，malloc有线程安全和非线程安全两个版本，两个区别在于内部是否使用递归锁，当编译程序时使用了_pthreads选项时使用线程安全版本，否则使用非线程安全版本。

自动重启

Linux中的某些系统调用在阻塞的过程中，如果接受到信号并转去处理信号处理函数，当从信号处理函数返回时这些阻塞的系统调用默认会返回EINTR。为了避免信号处理函数对阻塞中的系统调用的打断，可以通过设置SA_RESTART标志的sigaction()来建立信号处理函数，从而令内核代表进程自动重启系统调用，而无需处理系统调用返回的EINTR错误。

并非所有的系统调用都支持自动重启，具体可参考《Linux/Unix系统编程手册（上册）》的21.5节。

参考资料

《Linux/Unix系统编程手册（上册）》

对可重性和线程安全的小结

Posted on Edited on

[TOC]

信号机制在Linux编程中一直是一个难点，因为信号往往跟进程、线程、定时器、I/O等多个层面都有牵涉，这些情况存在错综复杂的关系，堪比娱乐圈错综复杂的男女关系，要想全面理解信号机制确实不易。

信号种类

在Linux中可以通过如下命令来查看所有的信号：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[kuring@localhost ~]$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

共64个信号，分为两种信号：非实时信号和实时信号。其中1-31个信号为非实时信号，32-64为实时信号。

当一信号在阻塞状态下产生多次信号，当解除该信号的阻塞后，非实时信号仅传递一次信号，而实时信号会传递多次。

对于非实时信号：内核会为每个信号维护一个信号掩码，并阻塞信号针对该进程的传递。如果将阻塞的信号发送给某进程，对该信号的传递将延时，直至从进程掩码中移除该信号为止。当从进程掩码中移除该信号时该信号将传递给该进程。如果信号在阻塞期间传递过多次该信号，信号解除阻塞后仅传递一次。

对于实时信号：实时信号采用队列化处理，一个实时信号的多个实例发送给进程，信号将会传递多次。可以制定伴随数据，用于产生信号时的数据传递。不同实时信号的传递顺序是固定的，优先传递信号编号小的。

信号阻塞

内核会为每个信号维护一个信号掩码，来阻塞内核将信号传递给该进程。如果将阻塞的信号发送给该进程，信号的传递将延后，从进程信号掩码中移除该信号后内核立刻将信号传递给该进程。如果一个信号在阻塞状态下产生多次，对于非实时信号稍后仅会传递一次，对于实时信号内核会进行排队处理，会传递多次。

信号处理函数

要想在进程中设置信号处理函数有两种选择：signal()和sigaction()。其中signal()函数提供的接口比较简单，但是在不同的UNIX系统之间存在差异，跨平台特性不是很好,signal()函数由于是C库函数，实现往往是采用sigaction()系统调用完成。sigaction()具有很好的跨平台性，但是使用较为复杂，但是却可以在信号处理程序中完成阻塞信号的作用。

在sigaction函数中可以指定调用信号处理函数时要阻塞的信号集，不允许这些信号中断信号处理函数的调用，直到信号处理函数调用完毕后信号才会传递。这一点通过signal函数是完不成的，利用signal函数设定的信号处理函数只能在信号处理函数开始时使用sigprocmask设置要阻塞的信号，在信号处理函数尾部利用sigprocmask还原信号，但在调用第一次调用sigprocmask函数之前和第二次调用sigprocmask函数之后的空白期内却无法防止要阻塞信号的传递。

信号处理函数中调用的函数尽量是异步信号安全的，C库中的函数不是异步信号安全的函数。

在信号处理函数中尽量避免访问全局变量，要访问全局变量可以使用volatile sig_atomic_t flag，volatile防止将编译器将变量优化到内存中，sig_atomic_t是一种整形数据类型，用来保证读写操作的原子性。

系统调用的中断

当系统调用阻塞时，之前创建了处理函数的信号传递过来。在信号处理函数返回后，默认情况下，系统调用会失败，并将errno置为EINTR。

如果调用指定了SA_RESTART标志的sigaction()函数来创建信号处理器函数，内核会在信号处理函数返回后自动重启系统调用，从而避免了信号处理函数对阻塞的系统调用产生的影响。比较不幸的是，并非所有的系统调用都支持该特性。

信号的同步生成和异步生成

这里的同步是对信号产生方式的描述，跟具体哪个信号无关。所有的信号均可同步生成，也可异步生成。

异步生成：引发信号产生的事件与进程的执行无关。例如，用户输入了中断字符、子进程终止等事件，这些信号的产生该进程是无法左右的。

同步生成：当执行特定的机制指令产生硬件异常时或进程使用raise()、kill()等向自身发生信号时，信号是同步传递的。这些信号的产生时间该进程是可以左右的。

信号传递的时机和顺序

同步产生的信号会立即传递给该进程。例如，当使用raise()函数向自身发送信号时，信号会在raise()调用前发生。

异步产生一个信号时，且在进程并未阻塞的情况下，信号也不会立即被传递。当且仅当进程正在执行，并且由内核态到用户态的下一次切换时才会传递信号。说人话就是在以下两种情况下会传递信号：进程获得调度时和系统调用完成时。这是因为内核会在进程在内核态和用户态进行的切换的时候才会检测信号。

非实时信号的传递顺序无法保障，实时信号的传递顺序是固定的，当多个不同的实时信号处于等待状态时，优先传递最小编号的信号。

信号和线程

信号模型是基于进程模型而设计的，应尽量避免在多线程中使用信号模型。

信号的发送可以针对整个进程，也可以针对特定线程。

当进程收到一个信号后，内核会任选一个线程来接收信号，并调用信号处理函数对信号进行处理。

每个线程可以独立设置信号掩码。

如果信号处理程序中断了对pthread_mutex_lock()和pthread_cond_wait()的调用，该调用会自动重启。

参考文章

《Linux/Unix系统编程手册》

Posted on Edited on

第一遍阅读unpv3后，对书中讲述的内容有了大体的认识，但对书中的具体细节地方却是早已忘记。重新阅读unpv3，这次不希望仍然是阅后即忘，于是通过编写代码的方式对书中的例子和注意事项加深理解。

为了能够将书中的很多细节问题理解清楚并且便于记忆，本文采用了编写书中代码并运行的方式，并将书中容易出错和意想不到的问题记在代码中。

本文的代码实例并未完全按照书中的代码实例，本着单个文件即能编译通过并运行的原则，本文对于很多系统调用并未做防御式编程处理。针对每个版本的程序中缺点和注意事项在代码中已经进行了标注。

鉴于高性能的epoll机制出现比较晚，晚于unp的编写时间，书中并未做介绍。

TCP客户端程序

客户端函数执行效率情况：select非阻塞式I/O版本>线程化版本>fork版本>select阻塞式I/O版本>停等版本，停等版本的执行效率非常低，在实际生产环境中不建议使用。

其中poll和select机制基本类似，书中并未给出poll版本。

停-等版本

最常规的实现思路，但效率非常低，且当程序阻塞在读取要发送内容时，程序是无法收到服务端的状态变化。

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
/**
 * 停-等版本
 * 该版本缺陷为当服务端发生某些事件时，客户端可能仍然阻塞于fgets调用中
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#define SERV_PORT 9877
#define MAXLINE 4096	/* max text line length */

void str_cli(FILE *fp, int sockfd)
{
	char sendline[MAXLINE], recvline[MAXLINE];
	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		/* 当阻塞在fgets函数时将服务器进程关闭时虽然给客户端发送了FIN信号，客户端并不会知道，
		 * 服务端关闭时第一次调用write服务器会返回RST，
		 * 当一个进程向某个收到RST的套接字执行写操作时，内核会向该进程发送一个SIGPIPE信号
		 * 该问题需要使用I/O复用技术来解决，或者使用fork处理的方式来解决
		 * */
		write(sockfd, sendline, strlen(sendline));
		int n = read(sockfd, recvline, MAXLINE);
		if (n == 0)
		{
			printf("str_cli: server terminated prematurely\n");
			exit(1);
		}

		// 向标准输出写内容，既可以使用write也可以使用fputs
		write(STDOUT_FILENO, recvline, n);

		// 使用fputs时需要注意将recvline数组有效内容的后面一位设置为'\0'
//		recvline[n] = '\0';
//		fputs(recvline, stdout);
	}
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
	{
		printf("usage: tcpcli <IPaddress>\n");
		exit(1);
	}

	// 当一个进程向某个收到RST的套接字执行写操作时，内核会向该进程发送一个SIGPIPE信号
	// 最好的方式是忽略此信号的处理方式，并在程序下面处理该异常情况
	signal(SIGPIPE, SIG_IGN);

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));

	str_cli(stdin, sockfd);		/* do it all */

	exit(0);
}

fork版本

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
/**
 * 阻塞式I/O的fork版本
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#define SERV_PORT 9877
#define MAXLINE 4096	/* max text line length */

/**
 * 即使服务端已经退出，子进程的read方法仍然能够感知到并且退出while循环，并给父进程发送SIGTERM,父进程对该信号的默认处理方式为退出
 * 优点：代码量比较少，每个进程只处理2个I/O流，从一个复制到另一个
 */
void str_cli(FILE *fp, int sockfd)
{
	char sendline[MAXLINE], recvline[MAXLINE];
	pid_t pid;
	if ((pid = fork()) == 0)
	{
		// child process : server -> stdout
		int n;
		while ((n = read(sockfd, recvline, MAXLINE)) > 0)
		{
			recvline[n] = '\0';
			fputs(recvline, stdout);
		}
		kill(getppid(), SIGTERM);
		exit(0);
	}

	// parent process : stdin -> server
	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		write(sockfd, sendline, strlen(sendline));
	}
	shutdown(sockfd, SHUT_WR);
	pause();
	return ;
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
	{
		printf("usage: tcpcli <IPaddress>\n");
		exit(1);
	}

	// 当一个进程向某个收到RST的套接字执行写操作时，内核会向该进程发送一个SIGPIPE信号
	// 最好的方式是忽略此信号的处理方式，并在程序下面处理该异常情况
	signal(SIGPIPE, SIG_IGN);

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) != 0)
	{
		printf("connect error...\n");
		exit(1);
	}

	str_cli(stdin, sockfd);		/* do it all */

	exit(0);
}

阻塞式I/O的select版本

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
/**
 * 阻塞式I/O的select版本
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#define SERV_PORT 9877
#define MAXLINE 4096	/* max text line length */

/**
 * 缺点：使用了阻塞式I/O，如果在向套接字调用write发送给服务器时，套接字缓冲区已满，write调用会阻塞，从而影响了后续的套接字缓冲区的读取
 */
void str_cli(FILE *fp, int sockfd)
{
	int maxfdp1;
	fd_set rset;
	char sendline[MAXLINE], recvline[MAXLINE];
	int stdineof = 0;
	FD_ZERO(&rset);
	for (; ;)
	{
		// select
		FD_SET(fileno(fp), &rset);
		FD_SET(sockfd, &rset);
		maxfdp1 = (fileno(fp) > sockfd ? fileno(fp) : sockfd) + 1;
		select(maxfdp1, &rset, NULL, NULL, NULL);

		// socket
		if (FD_ISSET(sockfd, &rset))
		{
			int n = read(sockfd, recvline, MAXLINE);
			if (n == 0)
			{
				if (stdineof == 1)
				{
					return ;
				}
				else
				{
					printf("str_cli: server terminated prematurely\n");
					exit(1);
				}
			}
			else if (n == -1)
			{
				exit(1);
			}
			recvline[n] = '\0';
			fputs(recvline, stdout);
//			write(STDOUT_FILENO, recvline, n);
		}

		// input
		if (FD_ISSET(fileno(fp), &rset))
		{
			// 此处不能使用fgets函数，该函数带有缓冲区功能，select跟带有缓冲区的c函数混合使用有问题
//			if (fgets(sendline, MAXLINE, fp) == NULL)
//			{
//				return ;
//			}
			int n = read(fileno(fp), sendline, MAXLINE);
			if (n == 0)
			{
				stdineof = 1;
				shutdown(sockfd, SHUT_WR);	// 关闭写
				FD_CLR(fileno(fp), &rset);
				continue;
			}
			else if (n == -1)
			{
				exit(1);
			}
			write(sockfd, sendline, n);
		}
	}
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
	{
		printf("usage: tcpcli <IPaddress>\n");
		exit(1);
	}

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) != 0)
	{
		printf("connect error...\n");
		exit(1);
	}

	str_cli(stdin, sockfd);		/* do it all */

	exit(0);
}

非阻塞式I/O的select版本

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
/**
 * 非阻塞式I/O的select版本
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <fcntl.h>

#define SERV_PORT 9877
#define MAXLINE 4096	/* max text line length */
#define max(a,b) ( ((a)>(b)) ? (a):(b) )

/**
 * 优点：速度是最快的，可以防止进程在做任何工作时发生阻塞
 * 缺点：同时管理4个不同的I/O流，每个流都是非阻塞的，需要考虑到4个流的部分读和部分写问题。编码量是最多的，需要引入缓冲区管理机制。
 */
void str_cli(FILE *fp, int sockfd)
{
	// 将socket、标准输入和标准输出描述符设置为非阻塞方式
	int val = fcntl(sockfd, F_GETFL, 0);
	fcntl(sockfd, F_SETFL, val | O_NONBLOCK);

	val = fcntl(STDIN_FILENO, F_GETFL, 0);
	fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK);

	val = fcntl(STDOUT_FILENO, F_GETFL, 0);
	fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK);

	char to[MAXLINE], fr[MAXLINE];
	char *toiptr, *tooptr, *friptr, *froptr;
	toiptr = tooptr = to;
	friptr = froptr = fr;
	int stdineof = 0;

	int maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
	fd_set rset, wset;
	for (; ;)
	{
		FD_ZERO(&rset);
		FD_ZERO(&wset);
		if (stdineof == 0 && toiptr < &to[MAXLINE])
		{
			FD_SET(STDIN_FILENO, &rset);
		}
		if (friptr < &fr[MAXLINE])
		{
			FD_SET(sockfd, &rset);
		}
		if (tooptr != toiptr)
		{
			FD_SET(sockfd, &wset);
		}
		if (froptr != friptr)
		{
			FD_SET(STDOUT_FILENO, &wset);
		}
		select(maxfdp1, &rset, &wset, NULL, NULL);	// select函数仍然是阻塞的
		// 标准输入
		if (FD_ISSET(STDIN_FILENO, &rset))
		{
			int n;
			if ((n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0)
			{
				// 对于非阻塞式IO，如果操作不能满足，相应系统调用会返回EWOULDBLOCK错误
				if (errno != EWOULDBLOCK)
				{
					printf("read error on stdin\n");
					exit(1);
				}
			}
			else if (n == 0)
			{
				fprintf(stderr, "EOF on stdin\n");
				stdineof = 1;
				if (tooptr == toiptr)
				{
					shutdown(sockfd, SHUT_WR);	// 缓冲区中没有数据要发送，关闭socket
				}
			}
			else
			{
				fprintf(stderr, "read %d bytes from stdin\n", n);
				toiptr += n;
				FD_SET(sockfd, &wset);
			}
		}

		// 从套接字读
		if (FD_ISSET(sockfd, &rset))
		{
			int n;
			if ((n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0)
			{
				if (errno != EWOULDBLOCK)
				{
					printf("read error on socket\n");
					exit(1);
				}
			}
			else if (n == 0)
			{
				fprintf(stderr, "EOF on socket\n");
				if (stdineof)
				{
					return ;
				}
				else
				{
					printf("server terminated prematurely\n");
					exit(1);
				}
			}
			else
			{
				fprintf(stderr, "read %d bytes from socket\n", n);
				friptr += n;
				FD_SET(STDOUT_FILENO, &wset);
			}
		}

		// 标准输出
		int n;
		if (FD_ISSET(STDOUT_FILENO, &wset) && ((n = friptr - froptr) > 0))
		{
			int nwritten;
			if ((nwritten = write(STDOUT_FILENO, froptr, n)) < 0)
			{
				if (errno != EWOULDBLOCK)
				{
					printf("write error to stdout\n");
					exit(1);
				}
			}
			else
			{
				fprintf(stderr, "wrote %d bytes to stdout\n", nwritten);
				froptr += nwritten;
				if (froptr == friptr)
				{
					froptr = friptr = fr;
				}
			}
		}

		// 向socket写
		if (FD_ISSET(sockfd, &wset) && ((n = toiptr - tooptr)) > 0)
		{
			int nwritten;
			if ((nwritten = write(sockfd, tooptr, n)) < 0)
			{
				if (errno != EWOULDBLOCK)
				{
					printf("write error to socket\n");
					exit(1);
				}
			}
			else
			{
				fprintf(stderr, "wrote %d bytes to socket\n", nwritten);
				tooptr += nwritten;
				if (tooptr == toiptr)
				{
					toiptr = tooptr = to;
					if (stdineof)
					{
						shutdown(sockfd, SHUT_WR);
					}
				}
			}
		}
	}

	return ;
}

/**
 * connect的非阻塞版本
 * 连接建立成功时，描述符变为可写；连接建立错误时，描述符变为即可读又可写
 * 优点：
 * 1、阻塞式的connect调用会消耗CPU时间，非阻塞式connect可以充分利用CPU时间，在等待的过程中可以处理其他工作
 * 2、可以同时建立多个连接，浏览器中会用到此技术
 * 3、阻塞式connect的函数超时过长，可以通过该函数设置超时时间
 * 4、阻塞式的套接字调用connect时，在TCP的三次握手完成之前被某些信号中断时并且connect未设置内核自动重启的标志时，connect将返回EINTR错误
 * 当再次调用connect等待未完成的连接时将会返回EADDRINUSE错误
 */
int connect_nonb(int sockfd, const struct sockaddr *saptr, socklen_t salen, int nsec)
{
	// 将套接字设置为非阻塞状态
	int flags = fcntl(sockfd, F_GETFL, 0);
	fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

	int error = 0;

	int n;
	if ((n = connect(sockfd, saptr, salen)) < 0)
	{
		// 连接未成功建立，正常情况下返回EINPROGRESS错误，表示操作正在处理
		if (errno != EINPROGRESS)
		{
			// EINPROGRESS表示连接建立已经启动，但是尚未完成
			return -1;
		}
	}
	else if (n == 0)
	{
		// 当服务器和客户端在一台主机上时会立即建立连接
		goto done;
	}

	// 当代码执行到如下过程中时，connect正在建立连接，可以在此位置执行业务相关代码
	// 当然真正使用时，在此位置加入其他代码并不合适，需要根据具体情况重新调整代码
	// 可以参照书中的web客户程序例子

	fd_set rset, wset;
	FD_ZERO(&rset);
	FD_SET(sockfd, &rset);
	wset = rset;

	struct timeval tval;
	tval.tv_sec = nsec;
	tval.tv_usec = 0;
	if ((n = select(sockfd + 1, &rset, &wset, NULL, nsec ? &tval : NULL)) == 0)
	{
		// 发生超时
		close(sockfd);
		errno = ETIMEDOUT;
		return -1;
	}

	// 当连接建立成功时sockfd变为可写，当连接建立失败时sockfd变为即可读又可写
	if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset))
	{
		int len = sizeof(error);
		// 非可移植性函数，连接建立成功返回0，连接建立失败将错误值返回给error
		// 连接建立失败时，有返回-1和返回0的情况
		if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
		{
			// solaris连接建立失败返回-1
			return -1;
		}
	}
	else
	{
		printf("select error:sockfd not set");
		exit(1);
	}
done:
	// 恢复套接字的文件状态标志
	fcntl(sockfd, F_SETFL, flags);
	if (error)
	{
		close(sockfd);
		errno = error;
		return -1;
	}
	return 0;
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
	{
		printf("usage: tcpcli <IPaddress>\n");
		exit(1);
	}

	// 当一个进程向某个收到RST的套接字执行写操作时，内核会向该进程发送一个SIGPIPE信号
	// 最好的方式是忽略此信号的处理方式，并在程序下面处理该异常情况
	signal(SIGPIPE, SIG_IGN);

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	//connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	if (connect_nonb(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr), 50) < 0)
	{
		printf("socket connect error\n");
		exit(1);
	}

	str_cli(stdin, sockfd);		/* do it all */

	exit(0);
}

TCP服务端程序

服务器程序要处理大量并发，在设计时更要注重效率。

fork版本

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
/**
 * fork版本
 * PPC(Process per Connection)模型
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

void sig_chld(int signo)
{
	if (signo != SIGIO)
	{
		return;
	}
	int stat;

	/* 此处不可以使用wait函数，当多个SIGCHLD信号同时发出时会因为信号覆盖而出现僵尸进程的情况
	pid_t pid = wait(&stat);
	printf("child %d terminated\n", pid);	// 非异步信号安全函数，此处不应该调用
	*/

	/* 使用非阻塞的参数WNOHANG来循环处理信号，避免信号丢失问题 */
	pid_t pid;
	while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
	{
		printf("child %d terminated\n", pid);
	}
}

void str_echo(int sockfd)
{
	ssize_t	n;
	char buf[MAXLINE];

again:
	while ( (n = read(sockfd, buf, MAXLINE)) > 0)
	{
		write(sockfd, buf, n);
	}

	if (n < 0 && errno == EINTR)
		goto again;
	else if (n < 0)
		printf("str_echo: read error\n");
}

/**
 * fork版本
 * 缺点：
 * 		1.fork需要将父进程的内存映像复制到子进程，并在子进程中复制所有的描述符，尽管现在的操作系统已经都实现了写时复制技术，但是耗时仍然比较多
 * 		2.父进程和子进程之间需要IPC机制进行通信，从子进程返回信息到父进程比较麻烦
 */
int main(int argc, char *argv[])
{
	signal(SIGCHLD, sig_chld);
    int listenfd, connfd;
    pid_t childpid;
    struct sockaddr_in cliaddr, servaddr;

    // socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1)
    {
		printf("socket error\n");
		exit(1);
	}

    // bind
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    if (bind(listenfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
    {
    	printf("bind error\n");
    	exit(1);
    }

    // listen
    // 套接字排队的最大连接数为20
    if (listen(listenfd, 20) == -1)
    {
    	printf("listen error\n");
    	exit(1);
    }

    for ( ; ; )
    {
    	socklen_t clilen = sizeof(cliaddr);
    	// 处理accept被信号中断时返回EINTR错误
		if ((connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
			}
			else
			{
				printf("accept error");
				exit(1);
			}
		}

		if ((childpid = fork()) == 0)
		{
			/* child process */
			close(listenfd); /* close listening socket */
			str_echo(connfd); /* process the request */
			exit(0);
		}
		close(connfd); /* parent closes connected socket */
	}
}

select版本

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
/**
 * select版本
 * 缺点：
 * 		1. 有最大并发数限制，一个进程最多打开FD_SETSIZE个文件描述符，FD_SETSIZE往往是1024或2048字节
 * 		2. select每次调用都会线性扫描全部的FD集合，这样效率就会呈现线性下降，把FD_SETSIZE改大的后果就是所有FD处理都慢慢来
 * 		3. 内核/用户空间内存拷贝问题，内核把FD消息通知给用户空间采取了内存拷贝方法
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <sys/select.h>
#include <strings.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

/**
 * 使用select的需要维护client数组和allset的描述符集
 */
int main(int argc, char *argv[])
{
    struct sockaddr_in cliaddr, servaddr;

    // socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1)
    {
    	printf("socket error\n");
    	exit(1);
    }
    printf("finish socket...\n");

    // bind
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    if (bind(listenfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
    {
    	printf("bind error\n");
    	exit(1);
    }
    printf("finish bind...\n");

    // listen
    // 套接字排队的最大连接数为20
    if (listen(listenfd, 20) == -1)
    {
    	printf("listen error\n");
    	exit(1);
    }
    printf("finish listening...\n");

    int maxfd = listenfd;
    int maxi = -1;
    int client[FD_SETSIZE];
    for (int i=0; i<FD_SETSIZE; i++)
    {
    	client[i] = -1;
    }
    fd_set allset;
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

    for ( ; ; )
    {
    	fd_set rset = allset;
    	int nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
    	if (FD_ISSET(listenfd, &rset))
    	{
    		// 设置client数组
    		socklen_t clilen = sizeof(cliaddr);
    		// 调用select时有个问题，见书中16.6节
    		// 如果调用accept时客户端已经关闭连接，此时accept会阻塞并直到新的客户端连接到来
    		// 为了解决该问题可以将套接字设置为非阻塞再调用accept
			int connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);
			printf("accept one client:%d...\n", connfd);
			int i = 0;
			for (; i<FD_SETSIZE; i++)
			{
				if (client[i] < 0)
				{
					client[i] = connfd;
					break;
				}
			}

			FD_SET(connfd, &allset);

			if (i == FD_SETSIZE)
			{
				printf("too many clients");
				exit(-1);
			}
			if (connfd > maxfd)
			{
				maxfd = connfd;
			}
			if (i > maxi)
			{
				maxi = i;
			}
			if (--nready <= 0)
			{
				continue;
			}
    	}

    	// 检测所有客户端的数据
    	for (int i=0; i<=maxi; i++)
    	{
    		if (client[i] < 0)
    		{
    			continue;
    		}
    		if (FD_ISSET(client[i], &rset))
    		{
    			int n;
    			char buf[MAXLINE];
    			printf("start reading form one client...\n");
    			if ((n = read(client[i], buf, MAXLINE)) == 0)
				{
    				close(client[i]);
    				FD_CLR(client[i], &allset);
    				client[i] = -1;
				}
    			else
    			{
    				write(client[i], buf, n);
    			}
    			if (--nready <= 0)
    			{
    				break;
    			}
    		}
    	}
	}
}

poll版本

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
/**
 * poll版本
 * poll版本的解决了select文件描述符限制问题，但是仍然具备select的缺点中的2和3
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>
#include <poll.h>
#include <stropts.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */
#define OPEN_MAX 1024  // 该宏已经从limit.h中移除，用来表示一个进程可以打开的最大描述符数目

/**
 * 使用select的缺点为需要维护client数组
 */
int main(int argc, char *argv[])
{
    struct sockaddr_in cliaddr, servaddr;

    // socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1)
    {
    	printf("socket error\n");
    	exit(1);
    }
    printf("finish socket...\n");

    // bind
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    if (bind(listenfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
    {
    	printf("bind error\n");
    	exit(1);
    }
    printf("finish bind...\n");

    // listen
    // 套接字排队的最大连接数为20
    if (listen(listenfd, 20) == -1)
    {
    	printf("listen error\n");
    	exit(1);
    }
    printf("finish listening...\n");

    struct pollfd client[OPEN_MAX];
    client[0].fd = listenfd;
    client[0].events = POLLIN;
    for (int i=1; i<OPEN_MAX; i++)
    {
    	client[i].fd = -1;
    }

    int maxi = 0;	// 当前client正在使用的最大下标

    for ( ; ; )
    {
    	int nready = poll(client, maxi + 1, -1);
    	if (client[0].revents & POLLIN)
    	{
    		// 设置client数组
    		socklen_t clilen = sizeof(cliaddr);
			int connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);
			printf("accept one client:%d...\n", connfd);
			int i = 1;
			for (; i<OPEN_MAX; i++)
			{
				if (client[i].fd < 0)
				{
					client[i].fd = connfd;
					break;
				}
			}

			if (i == OPEN_MAX)
			{
				printf("too many clients");
				exit(-1);
			}
			client[i].events = POLLIN;
			if (i > maxi)
			{
				maxi = i;
			}
			if (--nready <= 0)
			{
				continue;
			}
    	}

    	// 检测所有客户端的数据
    	for (int i=0; i<=maxi; i++)
    	{
    		if (client[i].fd < 0)
    		{
    			continue;
    		}
    		if (client[i].revents & (POLLIN | POLLERR))
    		{
    			int n;
    			char buf[MAXLINE];
    			printf("start reading form one client...\n");
    			if ((n = read(client[i].fd, buf, MAXLINE)) < 0)
				{
    				if (errno == ECONNRESET)
    				{
    					close(client[i].fd);
    					client[i].fd = -1;
    				}
    				else
    				{
    					printf("read client error\n");
    					exit(-1);
    				}
				}
    			else if (n == 0)
    			{
    				printf("client %d close\n", client[i].fd);
    				close(client[i].fd);
    				client[i].fd = -1;
    			}
    			else
    			{
    				write(client[i].fd, buf, n);
    			}
    			if (--nready <= 0)
    			{
    				break;
    			}
    		}
    	}
	}
}

多线程版本

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
/**
 * 多线程版本
 * TPC(Thread Per Connection)模型
 * 线程的开销虽然比进程小，但是仍然有比较大开销，因此并发数不是很高
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>
#include <pthread.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

void str_echo(int sockfd)
{
	ssize_t	n;
	char buf[MAXLINE];

again:
	while ( (n = read(sockfd, buf, MAXLINE)) > 0)
	{
		write(sockfd, buf, n);
	}

	if (n < 0 && errno == EINTR)
		goto again;
	else if (n < 0)
		printf("str_echo: read error\n");
}

static void *doit(void *arg)
{
	pthread_detach(pthread_self());
	str_echo((int)arg);
	close((int)arg);
	printf("close socket...\n");
	return NULL;
}

int main(int argc, char *argv[])
{
    int listenfd, connfd;
    struct sockaddr_in cliaddr, servaddr;

    // socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1)
    {
		printf("socket error\n");
		exit(1);
	}

    // bind
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    if (bind(listenfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
    {
    	printf("bind error\n");
    	exit(1);
    }

    // listen
    // 套接字排队的最大连接数为20
    if (listen(listenfd, 20) == -1)
    {
    	printf("listen error\n");
    	exit(1);
    }

    for ( ; ; )
    {
    	socklen_t clilen = sizeof(cliaddr);
    	// 处理accept被信号中断时返回EINTR错误
		if ((connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen)) < 0)
		{
			if (errno == EINTR)
			{
				continue;
			}
			else
			{
				printf("accept error");
				exit(1);
			}
		}
		printf("receive new client...\n");
		pthread_t tid;
		pthread_create(&tid, NULL, &doit, (void *)connfd);
	}
}

UDP

由于udp比较简单，书中并未将udp协议当做重点来讲解。

UDP客户端程序

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
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

// sendto、recvfrom方式
void dg_cli(FILE *fp, int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	struct sockaddr *preply_addr = (struct sockaddr *)malloc(servlen);

	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
		int len = servlen;
		int n = recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
		// 为了防止接收到其他进程的数据，通过条件判断去除
		if (len != servlen || memcmp(pservaddr, preply_addr, len) != 0)
		{
			printf("reply from others (!ignore)\n");
			continue;
		}
		recvline[n] = 0;
		fputs(recvline, stdout);
	}
}

// connect、write、read方式
void dg_cli2(FILE *fp, int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
	char sendline[MAXLINE], recvline[MAXLINE + 1];

	connect(sockfd, (struct sockaddr *)pservaddr, servlen);

	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		write(sockfd, sendline, strlen(sendline));
		int n = read(sockfd, recvline, MAXLINE);
		recvline[n] = 0;
		fputs(recvline, stdout);
	}
}

int main(int argc, char *argv[])
{
	if (argc != 2)
	{
		printf("usage: tcpcli <IPaddress>\n");
		exit(1);
	}

	struct sockaddr_in servaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	dg_cli2(stdin, sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	exit(0);
}

UDP服务端程序

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
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

void dg_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
{
	char mesg[MAXLINE];
	for (;;)
	{
		socklen_t len = clilen;
		int n;
		bzero(mesg, MAXLINE);
		if ((n = recvfrom(sockfd, mesg, MAXLINE, 0,  pcliaddr, &len)) < 0)
		{
			close(sockfd);
			printf("recvfrom error, error=%m\n");
			exit(1);
		}
		printf("recv %s\n", mesg);
		sendto(sockfd, mesg, n, 0, pcliaddr, len);
	}
}

int main(int argc, char *argv[])
{
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	struct sockaddr_in servaddr, cliaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	if (bind(sockfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
	{
		printf("bind error\n");
		exit(1);
	}

	dg_echo(sockfd, (struct sockaddr*)&cliaddr, sizeof(cliaddr));
}

UDP服务端信号驱动式I/O版本

信号驱动式I/O：进程执行I/O系统调用告知内核启动某个I/O操作，内核启动I/O操作后立即返回到进程。进程在I/O操作发生期间继续执行。当操作完成或遇到错误时，内核以进程在I/O系统调用中指定的方式通知进程。

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
/**
 * 信号驱动式I/O在TCP套接字用途不大，该信号产生的过于频繁，它的出现并未指示发生的事情
 */
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <strings.h>
#include <fcntl.h>

#define SERV_PORT 9877
#define MAXLINE		4096	/* max text line length */

static int sockfd;

#define MAXDG 4096


typedef struct
{
	void *dg_data;				// 实际数据
	size_t dg_len;				// 实际数据长度
	struct sockaddr *dg_sa;		// 包含客户端地址
	socklen_t dg_salen;			// 客户端地址长度
} DG;

#define QSIZE 8
static DG dg[QSIZE];			// 存放数据的环形缓冲区

static long cntread[QSIZE + 1];
// 需要处理的下一个数据元素的下标
static int iget;
// 存放数据元素的下一个位置
static int iput;
static int nqueue;				// 队列中的数据个数
static socklen_t clilen;

static void sig_hup(int signo)
{
	int i=0;
	for (; i <= QSIZE; i++)
	{
		printf("cntread[%d = %ld\n", i, cntread[i]);
	}
}

static void sig_io(int signo)
{
	int nread;
	// 为了解决非实时信号不排队问题，采用循环读取方式
	for (nread = 0; ; )
	{
		// 检查队列是否已满
		if (nread >= QSIZE)
		{
			printf("receive overflow\n");
			exit(1);
		}
		DG *ptr = &dg[iput];
		ptr->dg_salen = clilen;
		ssize_t len = recvfrom(sockfd, ptr->dg_data, MAXDG, 0, ptr->dg_sa, &ptr->dg_salen);
		if (len < 0)
		{
			if (errno == EWOULDBLOCK)
			{
				break;
			}
			else
			{
				printf("recvfrom error\n");
				exit(1);
			}
		}
		ptr->dg_len = len;
		nread++;
		nqueue++;
		if (++iput >= QSIZE)
		{
			iput = 0;
		}
	}
	cntread[nread]++;
}

void dg_echo(int sockfd_arg, struct sockaddr *pcliaddr, socklen_t clilen_arg)
{
	sockfd = sockfd_arg;
	clilen = clilen_arg;
	int i = 0;
	for (; i<QSIZE; i++)
	{
		dg[i].dg_data = malloc(MAXDG);
		dg[i].dg_sa = (struct sockaddr *)malloc(clilen);
		dg[i].dg_salen = clilen;
	}
	iget = iput = nqueue = 0;
	signal(SIGHUP, sig_hup);

	// 在启动信号I/O前设置信号处理函数
	signal(SIGIO, sig_io);

	// 设置接收信号通知的进程，让本进程接收SIGIO信号
	fcntl(sockfd, F_SETOWN, getpid());

	// 为了能够在得到I/O事件后重复执行I/O操作，需要将文件描述符设置为非阻塞方式
	// O_ASYNC表示在文件描述符上使用信号驱动I/O
	int flags = fcntl(sockfd, F_GETFL);
	fcntl(sockfd, F_SETFL, flags | O_ASYNC | O_NONBLOCK);

	sigset_t zeromask, newmask, oldmask;
	sigemptyset(&zeromask);
	sigemptyset(&newmask);
	sigemptyset(&oldmask);

	// 设置新的信号掩码，阻塞SIGIO信号
	sigaddset(&newmask, SIGIO);
	sigprocmask(SIG_BLOCK, &newmask, &oldmask);
	for (; ;)
	{
		while (nqueue == 0)
		{
			// 挂起进程直到收到任何信号，该函数返回后SIGIO继续被阻塞
			sigsuspend(&zeromask);
		}
		// 解除SIGIO的阻塞
		sigprocmask(SIG_SETMASK, &oldmask, NULL);
		sendto(sockfd, dg[iget].dg_data, dg[iget].dg_len, 0, dg[iget].dg_sa, dg[iget].dg_salen);
		if (++iget >= QSIZE)
		{
			iget = 0;
		}
		// 为了能够修改nqueue的值，阻塞SIGIO信号
		sigprocmask(SIG_BLOCK, &newmask, &oldmask);
		nqueue--;
	}
}

int main(int argc, char *argv[])
{
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	struct sockaddr_in servaddr, cliaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	if (bind(sockfd,  (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
	{
		printf("bind error\n");
		exit(1);
	}

	dg_echo(sockfd, (struct sockaddr*)&cliaddr, sizeof(cliaddr));
	return 1;
}

相关下载

本文中的实例，代码采用eclipse CDT编写，可以直接导入eclipse中运行。

下载实例

Posted on Edited on

最近这段时间回顾了下python，距离上次使用python已经超过两年的时间了。

相对于c++语言，python要灵活许多，对于工作中的一些小问题的解决可以通过python来实现比较高效和方便，比如网页的抓取和解析。甚至对于非IT的工作，也可以通过脚本的方式来解决，只要是工作中遇到反复处理的体力活劳动就可以考虑利用编程方式来解决。

本文以我的博客的文档列表页面为例，利用python对页面中的文章名进行提取。

文章列表页中的文章列表部分的url如下：

1
2
3
4
5
6
7
<ul class="listing">
    <li class="listing-item"><span class="date">2014-12-03</span><a href="/post/linux_funtion_advance_feature"  title="Linux函数高级特性" >Linux函数高级特性</a>
    </li>
    <li class="listing-item"><span class="date">2014-12-02</span><a href="/post/cgdb"  title="cgdb的使用" >cgdb的使用</a>
    </li>
...
</ul>

requests模块的安装

requests模块用于加载要请求的web页面。

在python的命令行中输入import requests，报错说明requests模块没有安装。

我这里打算采用easy_install的在线安装方式安装，发现系统中并不存在easy_install命令，输入sudo apt-get install python-setuptools来安装easy_install工具。

执行sudo easy_install requests安装requests模块。

Beautiful Soup安装

为了能够对页面中的内容进行解析，本文使用Beautiful Soup。当然，本文的例子需求较简单，完全可以使用分析字符串的方式。

执行sudo easy_install beautifulsoup4即可安装。

编码问题

python的编码问题确实是一个很头大的问题，尤其是对于不熟悉python的菜鸟。

python自身的编码问题就已经够头大的了，碰巧requests模块也有一个编码问题的bug，具体的bug见参考文章。

代码

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
#!/usr/bin/env python                                                                                                                                                           
# -*- coding: utf-8 -*-

' a http parse test programe '

__author__ = 'kuring lv'


import requests
import bs4

archives_url = "http://kuring.me/archive"

def start_parse(url) :
    print "开始获取(%s)内容" % url
    response = requests.get(url)
    print "获取网页内容完毕"
    
    soup = bs4.BeautifulSoup(response.content.decode("utf-8"))
    #soup = bs4.BeautifulSoup(response.text);
    
    # 为了防止漏掉调用close方法，这里使用了with语句
    # 写入到文件中的编码为utf-8
    with open('archives.txt', 'w') as f :
        for archive in soup.select("li.listing-item a") :
            f.write(archive.get_text().encode('utf-8') + "\n")
            print archive.get_text().encode('utf-8')

# 当命令行运行该模块时，__name__等于'__main__'
# 其他模块导入该模块时，__name__等于'parse_html'
if __name__ == '__main__' :
    start_parse(archives_url)

参考文章

Posted on Edited on

最近学习了《GNU Make项目管理》，改进了我之前一直在用的Makefile文件，解决我之前的Makefile中一直存在的修改依赖头文件后不能自动编译cpp文件的问题。本文列举了我常用的两个Makefile文件，其中第一个为我常用的Makefile，第二个为从网上找到的其他Makefile文件。

第一个Makefile

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
all:
INCLUDE = -I./

FLAGS = -g -Wall $(INCLUDE)
FLAGS += -fPIC

LIBDIR = -lz -lm -lcrypto

LINK = $(LIBDIR) -lpthread

GCC = g++

# for C++ language
CODE.cpp = main.cpp \
			trim.cpp

CPP.o = $(CODE.cpp:.cpp=.o)
OBJS.d = $(CODE.cpp:.cpp=.d)

OBJS.o = $(CPP.o)

# 解决头文件依赖
-include $(subst .cpp,.d,$(CODE.cpp))

%.d: %.cpp
	$(GCC) -M $(FLAGS) $< > $@.$$$$;		\
	sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@;	\
	rm -f $@.$$$$

# rule for C++ language
%.o : %.cpp	
	$(GCC) $(FLAGS) -o $@ -c $<	
	@echo $*.o build successfully!......

TARGET = main
	
$(TARGET) : $(OBJS.o) 
	$(GCC) $(OBJS.o) -o $(TARGET) $(LINK)
	@echo $(TARGET) BUILD OK!.........

all : $(TARGET)

.PHONY:
clean:
	rm -rf $(TARGET)
	rm -rf $(OBJS.o)
	rm -rf $(OBJS.d)
	rm -rf *.d

该文件特点为需要手工将需要编译的源文件手动添加到Makefile中，可能比较麻烦，但是编译时比较灵活。可以随意修改需要编译源文件的顺序和是否需要编译源文件。

第二个Makefile

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
###########################################################
#
# KEFILE FOR C/C++ PROJECT
# Author: swm8023 <swm8023@gmail.com>
# Date:   2014/01/30
#
###########################################################

.PHONY: all clean
all: 

# annotation when release version
DEBUG       := y
TARGET_PROG := main

# project directory	
DEBUG_DIR   := ./Debug
RELEASE_DIR := ./Release
BIN_DIR     := $(if $(DEBUG), $(DEBUG_DIR), $(RELEASE_DIR))

# shell command
CC    := gcc
CXX   := g++
RM    := rm -rf
MKDIR := mkdir -p
SED   := sed
MV    := mv

# init sources & objects & depends
sources_all := $(shell find . -name "*.c" -o -name "*.cpp" -o -name "*.h")
sources_c   := $(filter %.c, $(sources_all))
sources_cpp := $(filter %.cpp, $(sources_all))
sources_h   := $(filter %.h, $(sources_all))
objs        := $(addprefix $(BIN_DIR)/,$(strip $(sources_cpp:.cpp=.o) $(sources_c:.c=.o)))
deps        := $(addprefix $(BIN_DIR)/,$(strip $(sources_cpp:.cpp=.d) $(sources_c:.c=.d)))

# create directory
$(foreach dirname,$(sort $(dir $(sources_c) $(sources_cpp))),\
  $(shell $(MKDIR) $(BIN_DIR)/$(dirname)))

# complie & link variable
CFLAGS     := $(if $(DEBUG),-g -O, -O2)
CFLAGS     += $(addprefix -I ,$(sort $(dir $(sources_h))))
CXXFLAGS    = $(CFLAGS)
LDFLAGS    := 
LOADLIBES  += #-L/usr/include/mysql
LDLIBS     += #-lpthread -lmysqlclient

# add vpath
vpath %.h $(sort $(dir $(sources_h)))
vpath %.c $(sort $(dir $(sources_c)))
vpath %.cpp $(sort $(dir $(sources_cpp)))

# generate depend files
# actually generate after object generated, beacasue it only used when next make)
ifneq "$(MAKECMDGOALS)" "clean"
sinclude $(deps)
endif

# make-depend(depend-file,source-file,object-file,cc)
define make-depend
  $(RM) $1;                                     \
  $4 $(CFLAGS) -MM $2 |                         \
  $(SED) 's,\($(notdir $3)\): ,$3: ,' > $1.tmp; \
  $(SED) -e 's/#.*//'                           \
         -e 's/^[^:]*: *//'                     \
         -e 's/ *\\$$//'                        \
         -e '/^$$/ d'                           \
         -e 's/$$/ :/' < $1.tmp >> $1.tmp;      \
  $(MV) $1.tmp $1;
endef

# rules to generate objects file
$(BIN_DIR)/%.o: %.c
	@$(call make-depend,$(patsubst %.o,%.d,$@),$<,$@,$(CC))
	$(CC) $(CFLAGS) -o $@ -c $<

$(BIN_DIR)/%.o: %.cpp
	@$(call make-depend,$(patsubst %.o,%.d,$@),$<,$@,$(CXX))
	$(CXX) $(CXXFLAGS) -o $@ -c $<

# add-target(target,objs,cc)
define add-target
  REAL_TARGET += $(BIN_DIR)/$1
  $(BIN_DIR)/$1: $2
	$3 $(LDFLAGS) $$^ $(LOADLIBES) $(LDLIBS) -o $$@
endef

# call add-target
$(foreach targ,$(TARGET_PROG),$(eval $(call add-target,$(targ),$(objs),$(CXX))))

all: $(REAL_TARGET) $(TARGET_LIBS)

clean: 
	$(RM) $(BIN_DIR)

该Makefile为从一个通用的C/C++ Makefile中直接获得的，为了避免原博客以后不能访问的情况，这里备份一下。

该Makefile可以动检测Makefile所在目录及其子目录中的.c和.cpp文件，并进行编译，不需要手动修改Makefile来填写需要编译的源文件，比较自动化。

相关参考

第二个Makefile文件的作者博客中的两篇文章：GNU Make学习总结（一）和GNU Make学习总结（二）

相关下载

一个包含上述两个Makefile的例子

Posted on Edited on

问题描述

一个最多包含n个正整数的文件，每个数小于n，其中n为10000000。要求升序排列整数列表，最多使用1MB的内存，运行时间尽可能短。

代码实现

#include <stdio.h>                                                                                                                                                              
#include <stdlib.h>

#define BITSPERWORD 32
#define SHIFT 5
#define MASK 0x1F
#define N 10000000

int a[1 + N/BITSPERWORD] = {0};

/**
 * i>>SHIFT相当于i/32，用于确定i在第几个int数组中
 * 其中i&MASK含义为i%32，用于确定在int中的第几位
 */
void set(int i)
{
    a[i >> SHIFT] |= (1 << (i & MASK));
}

void clr(int i)
{
    a[i >> SHIFT] &= (0 << (i & MASK));
}

int test(int i)
{
    return a[i >> SHIFT] & (1 << (i & MASK));
}

int main(void)
{
    int i;
    while (scanf("%d", &i) != EOF)
    {
        set(i);
    }
    for (i=0; i<N; i++)
    {
        if (test(i))
        {
            printf("%d\n", i);
        }
    }
    return 0;
}

习题5

通过shell命令echo "scale=2; 10000000 / 1024 / 8 / 1024.0" | bc计算该程序运行时至少需要的存储空间为1.19MB，如果仅提供了1MB的存储空间，则需要更改上述程序的处理方式。

可采用多趟算法，多趟读入输入数据，每次完成一步。针对该题，可采用2步来完成，int数组的大小变更为5000000/8，比之前小了一半。第一步处理0-4999999之间的数据，第二步处理5000000-999999之间的数据。

习题6

如果是每个整数至少出现10次，而不是原先的一次。可以使用4bit来统计出现的次数，申请的数组大小变为了10000000/2。只要是每个整数有出现的最多次数上限该种处理方式就合适，当然整数出现的上限不能太大，否则该算法就没有了任何优势。

习题9

对一个大的数组的初始化操作需要耗费一些时间，为了消除数组的初始化，可以通过两个额外的数组来解决，这是典型的用空间换时间的方法。

      +---+---+---+---+---+---+---+----+
data  |   |   | 3 |   | 2 |   | 8 |    |
      +---+---+---+---+---+---+---+----+
                                        
      +---+---+---+---+---+---+---+----+
from  |   |   | 0 |   | 2 |   | 1 |    |
      +---+---+---+---+---+---+---+----+
                                        
      +---+---+---+---+---+---+---+----+
to    | 1 | 5 | 3 |   |   |   |   |    |
      +---+---+---+---+---+---+---+----+
                                        
                    ^                   
                    +                   
                   top

上图中data为要初始化的数组，from和to为辅助数组。如果data[i]已经初始化，则from[i]<top，to[from[i]]=i。from是一个简单的标识，to和top确保了from中不会写入内存中的随机内容。

习题11

该题的答案太他妈逗了，为了能够解决两地之间的数据传输瓶颈，作者给出的答案居然是用信鸽传输图片的底片后再将底片放大的方式来代替原先的用汽车运输的方式，这就是中国古代的飞鸽传书啊。

习题12

该题在《三傻大闹宝莱坞》中见过，这跟编程毛线关系也没有啊。

Posted on Edited on

本文以从服务器下载一个文件为例，讲解HTTP的断点续传功能。

客户端IP地址为：192.168.1.2
服务器IP地址为：192.168.1.3

客户端向服务器发送请求

客户端向服务器发送的请求为：

1
2
3
4
5
6
7
GET /deepc.a HTTP/1.1
Host: 192.168.100.189
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.14 Safari/537.36
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6

从中可以看出请求的文件名为deepc.a文件。

客户端向服务器发送具体请求

1
2
3
4
5
6
7
8
9
GET /deepc.a HTTP/1.1
Host: 192.168.100.189
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.14 Safari/537.36
Accept: */*
Referer: http://192.168.100.189/deepc.a
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
Range: bytes=0-32767

Range字段表示请求文件的范围为0-32767。

服务器响应

第一次服务器的HTTP响应报文如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
GET /deepc.a HTTP/1.1
Host: 192.168.1.3
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.14 Safari/537.36
Accept: */*
Referer: http://192.168.1.3/deepc.a
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
Range: bytes=0-32767

HTTP/1.1 206 Partial Content
Date: Sun, 04 May 2014 05:14:54 GMT
Server: Apache/2.4.4 (Win32) PHP/5.4.16
Last-Modified: Sat, 03 May 2014 00:43:22 GMT
ETag: "7efce6-4f8742f6ed9b2"
Accept-Ranges: bytes
Content-Length: 32768
Content-Range: bytes 0-32767/8322278
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive

HTTP的状态为206，表示服务器已经处理了部分HTTP相应。其中Content-Range字段表示服务器已经响应了0-32767个字节的文件内容。8322278表示文件的总长度为8322278字节。

客户端继续向服务器发送请求

客户端根据上次HTTP报文中服务器已经返回给的客户端的数据情况继续向服务器发送请求报文，向服务器发送的请求报文内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
GET /deepc.a HTTP/1.1
Host: 192.168.100.189
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.14 Safari/537.36
Accept: */*
Referer: http://192.168.100.189/deepc.a
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
Range: bytes=32768-8322277
If-Range: "7efce6-4f8742f6ed9b2"

HTTP/1.1 206 Partial Content
Date: Sun, 04 May 2014 05:14:54 GMT
Server: Apache/2.4.4 (Win32) PHP/5.4.16
Last-Modified: Sat, 03 May 2014 00:43:22 GMT
ETag: "7efce6-4f8742f6ed9b2"
Accept-Ranges: bytes
Content-Length: 8289510
Content-Range: bytes 32768-8322277/8322278
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive

Content-Range的内容表示客户端向服务器请求文件中32768-8322277之间的字节数据。

第二次服务器的HTTP响应报文如下：

1
2
3
4
5
6
7
8
9
10
HTTP/1.1 206 Partial Content
Date: Sun, 04 May 2014 05:14:54 GMT
Server: Apache/2.4.4 (Win32) PHP/5.4.16
Last-Modified: Sat, 03 May 2014 00:43:22 GMT
ETag: "7efce6-4f8742f6ed9b2"
Accept-Ranges: bytes
Content-Length: 8289510
Content-Range: bytes 32768-8322277/8322278
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive

表示服务器已经相应完成了32768-8322277之间的数据。

Posted on Edited on

为了避免linux下的控制台程序A死掉，可以通过一个另外一个程序B来监听A程序，当A程序异常退出时将B程序带起来。当然程序设计的最好方式为程序不崩溃，但是程序中存在bug很难避免，该方法还是有一定的实践意义。对于B程序可以通过shell脚本或者单独一个应用程序来解决。本文将通过shell脚本来解决此问题。

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
#!/bin/bash

check_process()
{
	# check parameter
	if [ $1 = "" ];
	then
		return -1
	fi

	# get the running process
	process_names=$(ps -ef | grep $1 | grep -v grep | awk '{print $8}')
	for process_name in $process_names
	do
		if [ $process_name = $1 ] ;
		then
			return 1
		fi
	done

	# not run and run the process
	echo "$(date) : process $1 not run, just run it"
	$1
	return 0
}

while [ 1 ];do
	check_process "/usr/bin/app/process"	# programe path
	sleep 5
done

将shell脚本在脱离控制台下可以运行

一旦断开了控制台，shell脚本就会由于接收到SIGHUP信号而退出。这里有两种思路来解决该问题，一种是通过系统的crontab来定期调用脚本程序，另外一种是通过神奇的screen程序来解决该问题，我这里通过screen程序来解决该问题，具体screen程序的应用见我的另外一篇文章《》。

应用程序为daemon方式运行

为了能够保证该脚本监控多个应用程序，需要将应用程序设置为daemon方式运行，可以调用函数daemon实现。也可以调用单独实现的daemon函数，具体代码如下：

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
void init_daemon(void) 
{ 
    int pid; 
    int i;  

    if(pid=fork()) 
        exit(0);//是父进程，结束父进程 
    else if(pid< 0)  
        exit(1);//fork失败，退出 
    //是第一子进程，后台继续执行 

    setsid();//第一子进程成为新的会话组长和进程组长 
    //并与控制终端分离 
    if(pid=fork()) 
        exit(0);//是第一子进程，结束第一子进程 
    else if(pid< 0)  
        exit(1);//fork失败，退出 
    //是第二子进程，继续 
    //第二子进程不再是会话组长 

    for(i=0;i< NOFILE;++i)//关闭打开的文件描述符 
        close(i); 
    chdir("/tmp");//改变工作目录到/tmp 
    umask(0);//重设文件创建掩模 
    return; 
}

Posted on Edited on

在github上可以fork别人的项目成为自己的项目，但是当fork的项目更新后自己fork的项目应该怎么怎么更新呢？我从网上看到了两种方式，一种是采用github的web界面中的操作来实现，具体是通过“Pull Request”功能来实现；另外一种是通过在本地合并代码分支的方式来解决。本文将采用第二种方式，以我最近fork的项目为例来说明。

将fork后自己的项目clone到本地

执行git clone https://github.com/kuring/leetcode.git即可将自己fork的代码更新到本地。

fork完成后的远程分支和所有分支情况如下：

1
2
3
4
5
6
7
kuring@T420:/data/git/leetcode$ git remote -v
origin	https://github.com/kuring/leetcode.git (fetch)
origin	https://github.com/kuring/leetcode.git (push)
kuring@T420:/data/git/leetcode$ git branch -a
* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/master

将fork之前的项目clone到本地

将fork之前的项目添加到本地的远程分支haoel中，执行git remote add haoel https://github.com/haoel/leetcode。

再查看一下远程分支和所有分支情况：

1
2
3
4
5
6
7
8
9
kuring@T420:/data/git/leetcode$ git remote -v
haoel	https://github.com/haoel/leetcode (fetch)
haoel	https://github.com/haoel/leetcode (push)
origin	https://github.com/kuring/leetcode.git (fetch)
origin	https://github.com/kuring/leetcode.git (push)
kuring@T420:/data/git/leetcode$ git branch -a
* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/master

将远程代码halel分支fetch到本地

执行git fetch haoel，此时的所有分支情况如下，可以看出多了一个remotes/haoel/master分支。

1
2
3
4
5
kuring@T420:/data/git/leetcode$ git branch -a
* master
  remotes/haoel/master
  remotes/origin/HEAD -> origin/master
  remotes/origin/master

将halel分支merge到本地的分支

执行git merge remotes/haoel/master，此时发现有冲突，提示内容如下：

1
2
3
4
uring@T420:/data/git/leetcode$ git merge haoel/master
自动合并 src/reverseInteger/reverseInteger.cpp
冲突（内容）：合并冲突于 src/reverseInteger/reverseInteger.cpp
自动合并失败，修正冲突然后提交修正的结果。

之所以出现上述错误，这是由于我在fork之后在本地修正了源代码中的一处bug，而在fork之后到现在的时间间隔内原作者haoel也正好修正了该bug。打开文件后发现存在如下的内容，其实就是代码风格的问题，我这里将错误进行修正。

1
2
3
4
5
36 <<<<<<< HEAD                                                                                                                                                                
37     while( x != 0 ){
38 =======
39     while( x != 0){
40 >>>>>>> haoel/master

如果没有冲突的情况下通过merge命令即会将haoel/master分支合并master分支并执行commit操作。可以通过git status命令看到当前冲突的文件和已经修改的文件。执行git status命令可以看到如下内容，说明未冲突的文件已经在暂存区，冲突的文件需要修改后执行add操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
kuring@T420:/data/git/leetcode$ git status
位于分支 master
您的分支与上游分支 'origin/master' 一致。

您有尚未合并的路径。
  （解决冲突并运行 "git commit"）

要提交的变更：

	修改:         src/3Sum/3Sum.cpp
	修改:         src/4Sum/4Sum.cpp
	修改:         src/LRUCache/LRUCache.cpp
	......	// 此处省略了很多重复的
	......

未合并的路径：
  （使用 "git add <file>..." 标记解决方案）

	双方修改：     src/reverseInteger/reverseInteger.cpp

解决完冲突后执行add操作后再通过git status命令查看的内容如下。通过git status命令却看不到已经解决的冲突文件，对于这一点我还是很理解，参考文章中的Git 分支 - 分支的新建与合并是可以看到已经解决的冲突文件的，因为执行git add后将解决完成冲突的文件放到了暂存区中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
kuring@T420:/data/git/leetcode$ git status
位于分支 master
您的分支与上游分支 'origin/master' 一致。

所有冲突已解决但您仍处于合并中。
  （使用 "git commit" 结束合并）

要提交的变更：

	修改:         src/3Sum/3Sum.cpp
	修改:         src/4Sum/4Sum.cpp
	修改:         src/LRUCache/LRUCache.cpp
	......	// 此处省略了很多重复的
	......

这里冲突后merge操作并没有执行commit操作，需要解决冲突后再手工执行commit操作，此时整个的同步操作就已经完成了。

结尾

如果隔一段时间后又需要同步项目了仅需要执行git fetch haoel命令以下的操作即可。

参考

由于git命令较多，为了便于查阅增加一处git data transprot commands

Git图解

Posted on Edited on

问题

Given n, generate all structurally unique BST’s (binary search trees) that store values 1…n.

For example,
Given n = 3, your program should return all 5 unique BST’s shown below.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

分析

要想能够生成多个树并存储到vector中，最容易想到的就是递归算法。要想能够递归，题目中提供的函数仅有一个参数，结合题目不能够完成递归的条件，考虑到unique binary search trees中的解法，需要递归具有两个参数的函数。

考虑到了递归的问题，还需要利用循环不断将树添加到vector中，这编写起来也是比较有难度，需要掌握循环的次数和什么时候将树添加到vector中。

代码

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
vector<TreeNode *> generateTrees(int n) {
	vector<TreeNode *> sub_tree = generateTrees(1, n);
	return sub_tree;
}

vector<TreeNode *> generateTrees(int low, int high) {
	vector<TreeNode *> result;
	if (low > high)
	{
		result.push_back(NULL);
		return result;
	}
	else if (low == high)
	{
		TreeNode *node = new TreeNode(low);
		result.push_back(node);
		return result;
	}
	
	for (int i=low; i<=high; i++)
	{
		vector<TreeNode *> left = generateTrees(low, i - 1);
		vector<TreeNode *> right = generateTrees(i + 1, high);
		for (int j=0; j<left.size(); j++)
		{
			for (int k=0; k<right.size(); k++)
			{
				TreeNode *root = new TreeNode(i);
				root->left = left[j];
				root->right = right[k];
				result.push_back(root);
			}
		}
	}
	return result;
}
0%