编译

wget http://httpsqs.googlecode.com/files/libevent-2.0.12-stable.tar.gz
tar zxvf libevent-2.0.12-stable.tar.gz
cd libevent-2.0.12-stable/
./configure --prefix=/usr/local/libevent-2.0.12-stable/
make
make install
cd ../

cd kesqs-0.1-bata1
make

使用帮助：

./kesqs -h

客户端：

参考api目录文件

附：

软件参考其它开源软件如kmessage,httpsqs另外此版本属于bata版本，仅用于测试。

kesqs-0.1-bata1.rar (12.23 K, 下载次数:0, 上传时间:Sat, 04 Feb 2012 23:45:24 +0000)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <err.h>
#include <event.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>

#define SERVER_PORT 5555

//error: two or more data types in declaration specifiers
//结构体定义的时候后面没写分号
struct client {
	//客户端socket
	int fd;
	//bufferedevent 对象
	struct bufferevent *buf_ev;
};

int setnonblock(int fd)
{
	int flags;
	
	flags = fcntl(fd, F_GETFL);
	if (flags < 0) {
		return flags;
	}
	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) {
		return -1;
	}
	return 0;
}
//写回读缓冲区。注意 bufferevent_write_buffer 将逐渐发送完输入的数据
void buffered_on_read(struct bufferevent *bev, void *arg) {
	bufferevent_write_buffer(bev, bev->input);
}
//当写缓冲为0时，libevent调用这个函数。我们写出这个函数只是因为libevent需要，但是我们没有使用它。
void buffered_on_write(struct bufferevent *bev, void *arg) {
	
}
//当基础的socket描述符发生错误时，libevent将调用这个函数
void buffered_on_error(struct bufferevent *bev, short ev, void *arg) {
	struct client *client = (struct client *)arg;
	if (ev & EVBUFFER_EOF) {
		printf("client disconnected\n");
	} else {
		warn("client socket error, disconnecting\n");
	}
	bufferevent_free(client->buf_ev);
	close(client->fd);
	free(client);
}
void on_accept(int fd, short ev, void *arg) {
	int client_fd;
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	struct client *client;

	client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
	if (client_fd < 0) {
		warn("accept faild");
		return;
	}

	if (setnonblock(client_fd) < 0) {
		warn("failed to set client socket non-blocking");
	}

	client = calloc(1, sizeof(*client));
	if (client == NULL) {
		err(1,"malloc failed");
	}
	client->fd = client_fd;
	/* 创建 buffered 事件。
	 * 第一个参数是引起事件的文件描述符，这里是客户端socket。
	 * 第二个参数是一个回调函数，当数据已经被socket读取并且对程序有效时，它被调用。
	 * 第三个参数是一个回调函数，当写缓冲区到达最小值时，它被调用。 
	 *		这通常意味着，当写入缓冲区长度为0时，这个回调函数将被调用。        
	 *		它必须被定义，但是实际上你可以在这个回调函数中不做任何处理。
	 * 第四个参数是一个回调函数，当有socket错误发生时，它被调用。         
	 *		在这里你可以探测客户端断开连接，或者其它的错误。
	 * 第五个参数用来存储一个将会传递给各个回调函数的参数。我们在这里存储客户数据对象。
	 */
	client->buf_ev = bufferevent_new(client_fd, buffered_on_read, buffered_on_write, buffered_on_error, client);

	/* 我们必须在回调函数被调用前，使它有效。 */
	bufferevent_enable(client->buf_ev, EV_READ);
}
int main(int argc, char *argv[])
{
	int listen_fd;
	struct sockaddr_in listen_addr;
	struct event ev_accept;
	int reuseaddr_on;

	event_init();
	listen_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (listen_fd < 0) {
		err(1, "listen failed");
	}

	memset(&listen_addr, 0, sizeof(listen_addr));
	listen_addr.sin_family = AF_INET;
	listen_addr.sin_addr.s_addr = INADDR_ANY;
	listen_addr.sin_port = htons(SERVER_PORT);
	if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0) {
		err(1, "bind failed");	
	}
	if (listen(listen_fd, 5) < 0) {
		err(1, "listen failed");
	}

	reuseaddr_on = 1;
	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on));

	if (setnonblock(listen_fd) < 0) {
		err(1, "failed to set server to non-blocking");
	}

	event_set(&ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, NULL);
	event_add(&ev_accept, NULL);

	event_dispatch();
	return 0;
}

参考：

http://code.google.com/p/ishbits/source/browse/trunk/libevent-examples/buffered-echo-server/libevent_echosrv_buffered.c

bufevent.c (3.84 K, 下载次数:0, 上传时间:Mon, 30 Jan 2012 13:38:02 +0000)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <event.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/queue.h>
#include <err.h>
#include <unistd.h>


//客户端发送的内容的长度
#define BUFLEN 1024

//全局变量
struct event ev_accept;
int socket_fd;

//内部函数，只能被本文件中的函数调用
static short ListenPort = 8080;
static long ListenAddr = INADDR_ANY;//任意地址，值就是0
static int   MaxConnections = 2;//连接请求队列的最大长度

struct bufferq {
	//buffer
	u_char *buf;

	//buf的长度
	int len;

	//写操作的偏移，用于buf的重试输出
	int offset;

	/*指向队列的前一个和后一个元素*/
	TAILQ_ENTRY(bufferq) entries;
};

//客户数据结构
struct client {
	//两个事件对象
	struct event ev_read;
	struct event ev_write;

	//存储的数据队列
	TAILQ_HEAD(, bufferq) writeq;
};

//将一个socket设置成非阻塞模式
//不论什么平台编写网络程序，都应该使用NONBLOCK socket的方式。这样可以保证你的程序至少不会在recv/send/accept/connect这些操作上发生block从而将整个网络服务都停下来
int setnonblock(int fd)
{
	int flags;
	//fcntl()用来操作文件描述符的一些特性
	if ((flags = fcntl(fd, F_GETFL)) == -1) {
		return -1;
	}

	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
		return -1;
	}
	return 0;
}

//当客户端socket准备好写入时，libevent调用这个函数
void on_write(int fd, short ev, void *arg)
{
	struct client *client = (struct client *)arg;
	struct bufferq *bufferq;
	int len, wlen;

	// 将第一个元素移出写队列
	bufferq = TAILQ_FIRST(&client->writeq);
	if (bufferq == NULL) {
		return;
	}

	//写buffer里的数据，如果有一部分已经输出过了，只输出剩余的部分
	len = bufferq->len - bufferq->offset;
	wlen = write(fd, bufferq->buf + bufferq->offset, len);
	if (wlen == -1) {
		//写操作被打断或不能写入数据
		if (errno == EINTR || errno == EAGAIN) {
			event_add(&client->ev_write, NULL);
			return;
		} else {
			//其它的sock错误
			//close(fd);
			//free(client);
			err(1, "write");
			return;
		}
	} else if (wlen < len) {
		//只输出了一部分数据，更新偏移量，调整写入事件
		bufferq->offset += wlen;
		event_add(&client->ev_write, NULL);
		return;
	}

	//队列中移除
	TAILQ_REMOVE(&client->writeq, bufferq, entries);
	//回收calloc申请的内存
	//free(bufferq->buf);//不是calloc申请的内存不能free
	free(bufferq);
}
//这个函数当客户端的socket可读时由libevent调用
void on_read(int fd, short ev, void *arg)
{
	struct client *client = (struct client *)arg;
	u_char buf[BUFLEN];
	int len, wlen;
	struct bufferq *bufferq;

	memset(&buf, 0, sizeof(buf));
	//会把参数fd 所指的文件传送count个字节到buf指针所指的内存中
	len = read(fd, buf, sizeof(buf));
	if (len == 0) {
		/* 客户端断开连接，在这里移除读事件并且释放客户数据结构 */
		printf("disconnected\n");
		close(fd);
		event_del(&client->ev_read);
		free(client);
		return;
	} else if (len < 0) {
		/* 出现了其它的错误，在这里关闭socket，移除事件并且释放客户数据结构 */
		printf("socket fail %s\n", strerror(errno));
		close(fd);
		event_del(&client->ev_read);
		free(client);
		return;
	}
	//如果client发送来bye，则断开连接
	if (!strcmp(buf, "bye\r\n")) {
		close(fd);
		event_del(&client->ev_read);
		free(client);
		return;
	}

	bufferq = calloc(1, sizeof(*bufferq));
	if (bufferq == NULL) {
		close(fd);
		event_del(&client->ev_read);
		free(client);
		printf("malloc fail");
		return;
	}
	bufferq->buf = buf;
	bufferq->len = len;
	bufferq->offset = 0;
	//插入队列
	TAILQ_INSERT_TAIL(&client->writeq, bufferq, entries);

	//写事件
	event_add(&client->ev_write, NULL);
}

/*
   当有一个连接请求准备被接受时，这个函数将被libevent调用并传递给三个变量: 
   int fd:触发事件的文件描述符. 
   short event:触发事件的类型EV_TIMEOUT,EV_SIGNAL, EV_READ, or EV_WRITE. 
   void* :由arg参数指定的变量. 
*/
void on_accept(int fd, short ev, void *arg)
{
	int cfd;
	struct sockaddr_in addr;
	socklen_t addrlen = sizeof(addr);
	int yes = 1;
	int retval;
	//为每个客户端建一个client而不是写成全局变量,从而可以接收多个请求
	struct client *client;

	//将从连接请求队列中获得连接信息，创建新的套接字，并返回该套接字的文件描述符。
	//新创建的套接字用于服务器与客户机的通信，而原来的套接字仍然处于监听状态。
	//该函数的第一个参数指定处于监听状态的流套接字
	cfd = accept(fd, (struct sockaddr *)&addr, &addrlen);
	if (cfd == -1) {
		printf("accept(): can not accept client connection");
		return;
	}
	if (setnonblock(cfd) == -1) {
		close(cfd);
		return;
	}

	//为新客户分配一个客户数据结构来保存这个客户状态
	client = calloc(1, sizeof(*client));
	if (client == NULL) {
		printf("calloc faild");
		close(cfd);
		return;
	}

	//设置与某个套接字关联的选项
	//参数二 IPPROTO_TCP:TCP选项
	//参数三 TCP_NODELAY 不使用Nagle算法 选择立即发送数据而不是等待产生更多的数据然后再一次发送
	//       更多参数TCP_NODELAY 和 TCP_CORK
	//参数四 新选项TCP_NODELAY的值
	if (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
		printf("setsockopt(): TCP_NODELAY %s\n", strerror(errno));
		close(cfd);
		return;
	}

	event_set(&client->ev_read, cfd, EV_READ | EV_PERSIST, on_read, client);
	event_add(&client->ev_read, NULL);
	
	event_set(&client->ev_write, cfd, EV_WRITE, on_write, client);
	//初始化客户端队列
	TAILQ_INIT(&client->writeq);
	printf("Accepted connection from %s\n", inet_ntoa(addr.sin_addr));
}
int create_socket(void)
{
	struct sockaddr_in sa;

	//socket函数来创建一个能够进行网络通信的套接字。
	//第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置AF_INET;
	//第二个参数指定要创建的套接字类型
	//流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM、原始套接字SOCK_RAW
	//第三个参数指定应用程序所使用的通信协议。
	socket_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (socket_fd == -1) {
		printf("socket(): can not create server socket\n");
		return -1;
	}
	if (setnonblock(socket_fd) == -1) {
		return -1;
	}

	//如何避免等待60秒之后才能重启服务
	//in case of 'address already in use' error message
	/*这个套接字选项通知内核，如果端口忙，但TCP状态位于 TIME_WAIT ，可以重用端口。
	  如果端口忙，而TCP状态位于其他状态，重用端口时依旧得到一个错误信息，指明"地址已经使用中"。
	  如果你的服务程序停止后想立即重启，而新套接字依旧使用同一端口，此时 SO_REUSEADDR 选项非常有用。
	  必须意识到，此时任何非期望数据到达，都可能导致服务程序反应混乱，不过这只是一种可能，事实上很不可能。
	*/
	int yes = 1;
	if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {
		//perror()用来将上一个函数发生错误的原因输出到标准设备(stderr) 
		perror("setsockopt failed");
		return -1;
	}


	//清空内存数据
	memset(&sa, 0, sizeof(sa));
	sa.sin_family = AF_INET;
	//htons将一个无符号短整型数值转换为网络字节序
	sa.sin_port = htons(ListenPort);
	//htonl将主机的无符号长整形数转换成网络字节顺序
	sa.sin_addr.s_addr = htonl(ListenAddr);

	//(struct sockaddr*)&sa将sa强制转换为sockaddr类型的指针
	/*struct sockaddr 
		数据结构用做bind、connect、recvfrom、sendto等函数的参数，指明地址信息。
		但一般编程中并不直接针对此数据结构操作，而是使用另一个与sockaddr等价的数据结构 struct sockaddr_in
		sockaddr_in和sockaddr是并列的结构，指向sockaddr_in的结构体的指针也可以指向
		sockadd的结构体，并代替它。也就是说，你可以使用sockaddr_in建立你所需要的信息,
		在最后用进行类型转换就可以了
	*/
	//bind函数用于将套接字绑定到一个已知的地址上
	if (bind(socket_fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
		close(socket_fd);
		printf("bind(): can not bind server socket");
		return -1;
	}
	
	//执行listen 之后套接字进入被动模式
	//MaxConnections 连接请求队列的最大长度,队列满了以后，将拒绝新的连接请求
	if (listen(socket_fd, MaxConnections) == -1) {
		printf("listen(): can not listen server socket");
		close(socket_fd);
		return -1;
	}

	/*
	   event_set的参数：
	   + 参数1:  为要创建的event
	   + 参数2:  file descriptor，创建纯计时器可以设置其为-1，即宏evtimer_set定义的那样
	   + 参数3:  设置event种类，常用的EV_READ, EV_WRITE, EV_PERSIST, EV_SIGNAL, EV_TIMEOUT，纯计时器设置该参数为0
	   + 参数4:  event被激活之后触发的callback函数
	   + 参数5:  传递给callback函数的参数
	   备注：
			如果初始化event的时候设置其为persistent的(设置了EV_PERSIST)，
			则使用event_add将其添加到侦听事件集合后(pending状态)，
			该event会持续保持pending状态，即该event可以无限次参加libevent的事件侦听。
			每当其被激活触发callback函数执行之后，该event自动从active转回为pending状态，
			继续参加libevent的侦听(当激活条件满足，又可以继续执行其callback)。
			除非在代码中使用event_del()函数将该event从libevent的侦听事件集合中删除。
			如果不通过设置EV_PERSIST使得event是persistent的，需要在event的callback中再次调用event_add
			(即在每次pending变为active之后，在callback中再将其设置为pending)
	 */
	event_set(&ev_accept, socket_fd, EV_READ | EV_PERSIST, on_accept, NULL);
	//将event添加到libevent侦听的事件集中
	if (event_add(&ev_accept, NULL) == -1) {
		printf("event_add(): can not add accept event into libevent");
		close(socket_fd);
		return -1;
	}
	return 0;
}

int main(int argc, char *argv[])
{
	int retval;
	
	//初始化event base 使用默认的全局current_base
	event_init();
	
	retval = create_socket();
	if (retval == -1) {
		exit(-1);
	}
	//event_dispatch() 启动事件队列系统，开始监听（并接受）请求
	event_dispatch();
	
	return 0;
}

参考：

http://code.google.com/p/ishbits/source/browse/trunk/libevent-examples/echo-server/libevent_echosrv2.c

socket.c (10.33 K, 下载次数:0, 上传时间:Mon, 30 Jan 2012 13:37:43 +0000)

http://alovelycat.blog.sohu.com/118756560.html

用 GDB 调试程序

http://zhangyafeikimi.iteye.com/blog/249885

• 单向列表(single-linked lists)
• 单向尾队列(single-linked tail queue)
• 列表(lists)
• 尾队列(tail queues)

尾队列图示

尾队列常用宏

使用示例

#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

/*
  定义一个结构体，它只是尾队列的一个元素
  它必须包含一个TAILQ_ENTRY来指向上一个和下一个元素
*/
struct tailq_entry {
	int value;

	TAILQ_ENTRY(tailq_entry) entries;
};

//定义队列的头部
TAILQ_HEAD(, tailq_entry) my_tailq_head;

int main(int argc, char  *argv[])
{
	//定义一个结构体指针
	struct tailq_entry *item;
	//定义另外一个指针
	struct tailq_entry *tmp_item;
	
	//初始化队列
	TAILQ_INIT(&my_tailq_head);

	int i;
	//在队列里添加10个元素
	for(i=0; i<10; i++) {
		//申请内存空间
		item = malloc(sizeof(*item));
		if (item == NULL) {
			perror("malloc failed");
			exit(-1);
		}
		//设置值
		item->value = i;

		/*
		   将元素加到队列尾部
		   参数1：指向队列头的指针
		   参数2：要添加的元素
		   参数3：结构体的变量名
		*/
		TAILQ_INSERT_TAIL(&my_tailq_head, item, entries);
	}

	//遍历队列
	printf("Forward traversal: ");
	TAILQ_FOREACH(item, &my_tailq_head, entries) {
		printf("%d ",item->value);
	}
	printf("\n");

	//添加一个新的元素
	printf("Adding new item after 5: ");
	TAILQ_FOREACH(item, &my_tailq_head, entries) {
		if (item->value == 5) {
			struct tailq_entry *new_item = malloc(sizeof(*new_item));
			if (new_item == NULL) {
				perror("malloc failed");
				exit(EXIT_FAILURE);
			}
			new_item->value = 10;
			//插入一个元素
			TAILQ_INSERT_AFTER(&my_tailq_head, item, new_item, entries);
			break;
		}
	}
	TAILQ_FOREACH(item, &my_tailq_head, entries) {
		printf("%d ", item->value);
	}
	printf("\n");

	//删除一个元素
	printf("Deleting item with value 3: ");
	for(item = TAILQ_FIRST(&my_tailq_head); item != NULL; item = tmp_item) {
		if (item->value == 3) {
			//删除一个元素
			TAILQ_REMOVE(&my_tailq_head, item, entries);
			//释放不需要的内存单元
			free(item);
			break;
		}
		tmp_item = TAILQ_NEXT(item, entries);
	}

	TAILQ_FOREACH(item, &my_tailq_head, entries) {
		printf("%d ", item->value);
	}
	printf("\n");

	//清空队列
	while (item = TAILQ_FIRST(&my_tailq_head)) {
		TAILQ_REMOVE(&my_tailq_head, item, entries);
		free(item);
	}

	//查看是否为空
	if (!TAILQ_EMPTY(&my_tailq_head)) {
		printf("tail queue is  NOT empty!\n");
	}

	return 0;
	
}

示例原文

http://code.google.com/p/ishbits/source/browse/trunk/libevent-examples/

tailq.c (2.26 K, 下载次数:0, 上传时间:Mon, 30 Jan 2012 13:39:23 +0000)

tailq-example-r30.tar.gz (5.27 K, 下载次数:0, 上传时间:Fri, 27 Jan 2012 22:53:31 +0000)

http://hedahai119.iteye.com/blog/736673

jquerycomet

http://code.google.com/p/jquerycomet/source/checkout

Comet：基于 HTTP 长连接的“服务器推”技术

http://www.ibm.com/developerworks/cn/web/wa-lo-comet/

Grizzly是一种应用程序框架

http://download.java.net/maven/2/com/sun/grizzly/

GlassFish 是一款强健的商业兼容应用服务器

http://glassfish.java.net/public/downloadsindex.html#top

vim .svnignore

每种要忽略的文件加一行，如：
*.pyc
*.cash
test.php

然后

svn propset svn:ignore -F .svnignore .
svn status

注意：

这个.svnignore文件在更改后都需要执行上面的添加操作

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <event.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <fcntl.h>

//内部函数，只能被本文件中的函数调用
static short ListenPort = 8080;
static long ListenAddr = INADDR_ANY;//任意地址，值就是0
static int   MaxConnections = 1024;

static int ServerSocket;
//创建event
static struct event ServerEvent;

//将一个socket设置成非阻塞模式
//不论什么平台编写网络程序，都应该使用NONBLOCK socket的方式。这样可以保证你的程序至少不会在recv/send/accept/connect这些操作上发生block从而将整个网络服务都停下来
int SetNonblock(int fd)
{
	int flags;
	//fcntl()用来操作文件描述符的一些特性
	if ((flags = fcntl(fd, F_GETFL)) == -1) {
		return -1;
	}

	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
		return -1;
	}
	return 0;
}

//这个函数当客户端的socket可读时由libevent调用
void ServerRead(int fd, short ev, void *arg)
{
	struct client *client = (struct client *)arg;
	u_char buf[8196];
	int len, wlen;

	//会把参数fd 所指的文件传送count个字节到buf指针所指的内存中
	len = read(fd, buf, sizeof(buf));
	if (len == 0) {
		/* 客户端断开连接，在这里移除读事件并且释放客户数据结构 */
		printf("disconnected\n");
		close(fd);
		event_del(&ServerEvent);
		free(client);
		return;
	} else if (len < 0) {
		/* 出现了其它的错误，在这里关闭socket，移除事件并且释放客户数据结构 */
		printf("socket fail %s\n", strerror(errno));
		close(fd);
		event_del(&ServerEvent);
		free(client);
		return;
	}
	/* 
	   为了简便，我们直接将数据写回到客户端。通常我们不能在非阻塞的应用程序中这么做，
       我们应该将数据放到队列中，等待可写事件的时候再写回客户端。 
	   如果使用多个终端进行socket连接会出现错误socket fail Bad file descriptor
	 */
	wlen = write(fd, buf, len);
	if (wlen < len) {
		printf("not all data write back to client\n");
	}
}

/*
   当有一个连接请求准备被接受时，这个函数将被libevent调用并传递给三个变量: 
   int fd:触发事件的文件描述符. 
   short event:触发事件的类型EV_TIMEOUT,EV_SIGNAL, EV_READ, or EV_WRITE. 
   void* :由arg参数指定的变量. 
*/
void ServerAccept(int fd, short ev, void *arg)
{
	int cfd;
	struct sockaddr_in addr;
	socklen_t addrlen = sizeof(addr);
	int yes = 1;
	int retval;

	//将从连接请求队列中获得连接信息，创建新的套接字，并返回该套接字的文件描述符。
	//新创建的套接字用于服务器与客户机的通信，而原来的套接字仍然处于监听状态。
	//该函数的第一个参数指定处于监听状态的流套接字
	cfd = accept(fd, (struct sockaddr *)&addr, &addrlen);
	if (cfd == -1) {
		printf("accept(): can not accept client connection");
		return;
	}
	if (SetNonblock(cfd) == -1) {
		close(cfd);
		return;
	}

	//设置与某个套接字关联的选项
	//参数二 IPPROTO_TCP:TCP选项
	//参数三 TCP_NODELAY 不使用Nagle算法 选择立即发送数据而不是等待产生更多的数据然后再一次发送
	//       更多参数TCP_NODELAY 和 TCP_CORK
	//参数四 新选项TCP_NODELAY的值
	if (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
		printf("setsockopt(): TCP_NODELAY %s\n", strerror(errno));
		close(cfd);
		return;
	}

	event_set(&ServerEvent, cfd, EV_READ | EV_PERSIST, ServerRead, NULL);
	event_add(&ServerEvent, NULL);
	
	printf("Accepted connection from %s\n", inet_ntoa(addr.sin_addr));
}
int NewSocket(void)
{
	struct sockaddr_in sa;

	//socket函数来创建一个能够进行网络通信的套接字。
	//第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置AF_INET;
	//第二个参数指定要创建的套接字类型
	//流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM、原始套接字SOCK_RAW
	//第三个参数指定应用程序所使用的通信协议。
	ServerSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (ServerSocket == -1) {
		printf("socket(): can not create server socket\n");
		return -1;
	}
	if (SetNonblock(ServerSocket) == -1) {
		return -1;
	}

	//清空内存数据
	memset(&sa, 0, sizeof(sa));
	sa.sin_family = AF_INET;
	//htons将一个无符号短整型数值转换为网络字节序
	sa.sin_port = htons(ListenPort);
	//htonl将主机的无符号长整形数转换成网络字节顺序
	sa.sin_addr.s_addr = htonl(ListenAddr);

	//(struct sockaddr*)&sa将sa强制转换为sockaddr类型的指针
	/*struct sockaddr 
		数据结构用做bind、connect、recvfrom、sendto等函数的参数，指明地址信息。
		但一般编程中并不直接针对此数据结构操作，而是使用另一个与sockaddr等价的数据结构 struct sockaddr_in
		sockaddr_in和sockaddr是并列的结构，指向sockaddr_in的结构体的指针也可以指向
		sockadd的结构体，并代替它。也就是说，你可以使用sockaddr_in建立你所需要的信息,
		在最后用进行类型转换就可以了
	*/
	//bind函数用于将套接字绑定到一个已知的地址上
	if (bind(ServerSocket, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
		close(ServerSocket);
		printf("bind(): can not bind server socket");
		return -1;
	}
	
	//执行listen 之后套接字进入被动模式
	//MaxConnections 连接请求队列的最大长度,队列满了以后，将拒绝新的连接请求
	if (listen(ServerSocket, MaxConnections) == -1) {
		printf("listen(): can not listen server socket");
		close(ServerSocket);
		return -1;
	}

	/*
	   event_set的参数：
	   + 参数1:  为要创建的event
	   + 参数2:  file descriptor，创建纯计时器可以设置其为-1，即宏evtimer_set定义的那样
	   + 参数3:  设置event种类，常用的EV_READ, EV_WRITE, EV_PERSIST, EV_SIGNAL, EV_TIMEOUT，纯计时器设置该参数为0
	   + 参数4:  event被激活之后触发的callback函数
	   + 参数5:  传递给callback函数的参数
	   备注：
			如果初始化event的时候设置其为persistent的(设置了EV_PERSIST)，
			则使用event_add将其添加到侦听事件集合后(pending状态)，
			该event会持续保持pending状态，即该event可以无限次参加libevent的事件侦听。
			每当其被激活触发callback函数执行之后，该event自动从active转回为pending状态，
			继续参加libevent的侦听(当激活条件满足，又可以继续执行其callback)。
			除非在代码中使用event_del()函数将该event从libevent的侦听事件集合中删除。
			如果不通过设置EV_PERSIST使得event是persistent的，需要在event的callback中再次调用event_add
			(即在每次pending变为active之后，在callback中再将其设置为pending)
	 */
	event_set(&ServerEvent, ServerSocket, EV_READ | EV_PERSIST, ServerAccept, NULL);
	//将event添加到libevent侦听的事件集中
	if (event_add(&ServerEvent, 0) == -1) {
		printf("event_add(): can not add accept event into libevent");
		close(ServerSocket);
		return -1;
	}
	return 0;
}

int main(int argc, char *argv[])
{
	int retval;
	
	//初始化event base 使用默认的全局current_base
	event_init();
	
	retval = NewSocket();
	if (retval == -1) {
		exit(-1);
	}
	//event_dispatch() 启动事件队列系统，开始监听（并接受）请求
	event_dispatch();
	
	return 0;
}

编译方法：

先安装libevent

wget http://httpsqs.googlecode.com/files/libevent-2.0.12-stable.tar.gz
tar zxvf libevent-2.0.12-stable.tar.gz
cd libevent-2.0.12-stable/
./configure --prefix=/usr/local/libevent-2.0.12-stable/
make
make install
cd ../

 编译

gcc socket.c -o socket -Wl,-rpath,/usr/local/libevent-2.0.12-stable/lib/ -L/usr/local/libevent-2.0.12-stable/lib/ -levent -I/usr/local/libevent-2.0.12-stable/include/

测试:

终端执行
./socket
另外开一个终端
telnet 127.0.0.1 8080

阅读：

http://nyim.blog.163.com/blog/static/241491642009112001525291/

http://www.cnblogs.com/cnspace/archive/2011/07/19/2110891.html
http://54min.com/post/non-blocking-socket-server-using-libevent.html

http://blog.sina.com.cn/s/blog_53a2ecbf010095db.html

http://code.google.com/p/ishbits/source/browse/trunk/libevent-examples/echo-server/libevent_echosrv1.c

socket.c (7.34 K, 下载次数:0, 上传时间:Fri, 27 Jan 2012 00:08:10 +0000)

将非阻塞的设置回阻塞可以用
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags & ~O_NONBLOCK);

#include <sys/resource.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    //在Linux系统中，Resouce limit指在一个进程的执行过程中，它所能得到的资源的限制，比如进程的corefile的最大值，虚拟内存的最大值等。
    struct rlimit rlim_new;
    struct rlimit rlim;

    //getrlimit查询设定最大的core文件,若成功返回值为0
    if (getrlimit(RLIMIT_CORE, &rlim)==0) {
        printf("old soft limit:%d\n", rlim.rlim_cur);
        printf("old hard limit:%d\n", rlim.rlim_max);
        //一个无限的限制由常量RLIM_INFINITY指定
        //rlim_t rlim_cur; /*当前（软）限制*/
        //rlim_t rlim_max; /*硬限制*/
        rlim_new.rlim_cur = rlim_new.rlim_max = RLIM_INFINITY;
        if (setrlimit(RLIMIT_CORE, &rlim_new)!=0) {
            /* failed. try raising just to the old max */
            rlim_new.rlim_cur = rlim_new.rlim_max = rlim.rlim_max;
            (void) setrlimit(RLIMIT_CORE, &rlim_new);
        }
    }

    if ((getrlimit(RLIMIT_CORE, &rlim)!=0) || rlim.rlim_cur==0) {
        exit(1);
    }
    printf("new soft limit:%d\n", rlim.rlim_cur);
    printf("new hard limit:%d\n", rlim.rlim_max);
}

#include <stdlib.h>
#include <sys/signal.h>

void SetupSignal() {
    struct sigaction sa;

    //在linux下写socket的程序的时候，如果尝试send到一个disconnected socket上，就会让底层抛出一个SIGPIPE信号。
    //这个信号的缺省处理方法是退出进程
    //重载这个信号的处理方法,如果接收到一个SIGPIPE信号，忽略该信号
    sa.sa_handler = SIG_IGN;
    sa.sa_flags = 0;
    //sigemptyset()用来将参数set信号集初始化并清空
    if (sigemptyset(&sa.sa_mask) == -1 ||
            sigaction(SIGPIPE, &sa, 0) == -1) {
        exit(-1);
    }
}

int main(int argc, char *argv[])
{
    SetupSignal();
    while(1){}
    return 0;
}

测试方法：

1.执行signal程序

通过另外的一个Linux终端查看程序使用的pid

ps -ef|grep signal

root      4234  3124 93 13:02 pts/3    00:00:06 ./signal

发送信号

kill -SIGPIPE 4234

可以看到signal程序不会退出

2.将main函数中SetupSignal();行注释掉编译

执行signal程序

通过另外的一个Linux终端查看程序使用的pid

ps -ef|grep signal

root      4253  3124 99 13:03 pts/3    00:00:02 ./signal

kill -SIGPIPE 4253

可以看到signal程序退出了

我们运行如下命令，可看到Linux支持的信号列表：

$ 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      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

列表中，编号为1 ~ 31的信号为传统UNIX支持的信号，是不可靠信号(非实时的)，编号为32 ~ 63的信号是后来扩充的，称做可靠信号(实时信号)。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。

下面我们对编号小于SIGRTMIN的信号进行讨论。

1) SIGHUP
本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。

登录Linux时，系统会分配给登录用户一个终端(Session)。在这个终端运行的所有程序，包括前台进程组和后台进程组，一般都属于这个Session。当用户退出Linux登录时，前台进程组和后台有对终端输出的进程将会收到SIGHUP信号。这个信号的默认操作为终止进程，因此前台进程组和后台有终端输出的进程就会中止。不过可以捕获这个信号，比如wget能捕获SIGHUP信号，并忽略它，这样就算退出了Linux登录，wget也能继续下载。

此外，对于与终端脱离关系的守护进程，这个信号用于通知它重新读取配置文件。

2) SIGINT
程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。

3) SIGQUIT
和SIGINT类似, 但由QUIT字符(通常是Ctrl-\)来控制. 进程在因收到SIGQUIT退出时会产生core文件, 在这个意义上类似于一个程序错误信号。

4) SIGILL
执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段. 堆栈溢出时也有可能产生这个信号。

5) SIGTRAP
由断点指令或其它trap指令产生. 由debugger使用。

6) SIGABRT
调用abort函数生成的信号。

7) SIGBUS
非法地址, 包括内存地址对齐(alignment)出错。比如访问一个四个字长的整数, 但其地址不是4的倍数。它与SIGSEGV的区别在于后者是由于对合法存储地址的非法访问触发的(如访问不属于自己存储空间或只读存储空间)。

8) SIGFPE
在发生致命的算术运算错误时发出. 不仅包括浮点运算错误, 还包括溢出及除数为0等其它所有的算术的错误。

9) SIGKILL
用来立即结束程序的运行. 本信号不能被阻塞、处理和忽略。如果管理员发现某个进程终止不了，可尝试发送这个信号。

10) SIGUSR1
留给用户使用

11) SIGSEGV
试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据.

12) SIGUSR2
留给用户使用

13) SIGPIPE
管道破裂。这个信号通常在进程间通信产生，比如采用FIFO(管道)通信的两个进程，读管道没打开或者意外终止就往管道写，写进程会收到SIGPIPE信号。此外用Socket通信的两个进程，写进程在写Socket的时候，读进程已经终止。

14) SIGALRM
时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号.

15) SIGTERM
程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号。如果进程终止不了，我们才会尝试SIGKILL。

17) SIGCHLD
子进程结束时, 父进程会收到这个信号。

如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程来接管)。

18) SIGCONT
让一个停止(stopped)的进程继续执行. 本信号不能被阻塞. 可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作. 例如, 重新显示提示符

19) SIGSTOP
停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略.

20) SIGTSTP
停止进程的运行, 但该信号可以被处理和忽略. 用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号

21) SIGTTIN
当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号. 缺省时这些进程会停止执行.

22) SIGTTOU
类似于SIGTTIN, 但在写终端(或修改终端模式)时收到.

23) SIGURG
有"紧急"数据或out-of-band数据到达socket时产生.

24) SIGXCPU
超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变。

25) SIGXFSZ
当进程企图扩大文件以至于超过文件大小资源限制。

26) SIGVTALRM
虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占用的CPU时间.

27) SIGPROF
类似于SIGALRM/SIGVTALRM, 但包括该进程用的CPU时间以及系统调用的时间.

28) SIGWINCH
窗口大小改变时发出.

29) SIGIO
文件描述符准备就绪, 可以开始进行输入/输出操作.

30) SIGPWR
Power failure

31) SIGSYS
非法的系统调用。

在以上列出的信号中，程序不可捕获、阻塞或忽略的信号有：SIGKILL,SIGSTOP
不能恢复至默认动作的信号有：SIGILL,SIGTRAP
默认会导致进程流产的信号有：SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGIOT,SIGQUIT,SIGSEGV,SIGTRAP,SIGXCPU,SIGXFSZ
默认会导致进程退出的信号有：SIGALRM,SIGHUP,SIGINT,SIGKILL,SIGPIPE,SIGPOLL,SIGPROF,SIGSYS,SIGTERM,SIGUSR1,SIGUSR2,SIGVTALRM
默认会导致进程停止的信号有：SIGSTOP,SIGTSTP,SIGTTIN,SIGTTOU
默认进程忽略的信号有：SIGCHLD,SIGPWR,SIGURG,SIGWINCH

此外，SIGIO在SVR4是退出，在4.3BSD中是忽略；SIGCONT在进程挂起时是继续，否则是忽略，不能被阻塞

原文：

http://hi.baidu.com/walfer/blog/item/fa649f457276f53e86947302.html

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

int daemonize(void)
{
        int fd;
        switch(fork()) {
                case -1:
                        return (-1);
                case 0:
                        break;
                default:
                        //将父进程结束,让子进程变成真正的孤儿进程,并被init进程接管
                        exit(0);
        }
        //子进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离
        setsid();

        if ((fd = open("daemon.log", O_CREAT|O_RDWR|O_APPEND, 0)) != -1) {
                //dup2(int oldhandle, int newhandle)复制文件句柄
                dup2(fd, STDIN_FILENO);
                dup2(fd, STDOUT_FILENO);
                dup2(fd, STDERR_FILENO);
                //0,1和2文件句柄分别与标准输入,标准输出,标准错误输出相关联
                //所以用户应用程序调用open函数打开文件时,默认都是以3索引为开始句柄
                //fd已经由新的句柄代替,关闭fd句柄
                if (fd > STDERR_FILENO) (void)close(fd);
        }
        return 0;
}

int main(int argc, char *argv[])
{
        daemonize();
        printf("%s\n","hello");
        return 0;
}

扩展阅读：

http://www.cnblogs.com/xuxm2007/archive/2011/07/29/2121280.html

http://blog.csdn.net/yyyzlf/article/details/5267954

http://docs.linuxtone.org/ebooks/C&CPP/c/ch34s03.html

#include <stdio.h>
//unix类系统定义符号常量的头文件
#include <unistd.h>
#include <stdlib.h>

void usage(void)
{
    printf("+--------------------------------------\n");
    printf("| -l <ip_addr> interface to listen on\n");
    printf("| -p <num> port num to listen on\n");
    printf("| -h print help and exit\n");
    printf("+--------------------------------------\n");
    printf("\n");
    return;
}
void ParseOptions(int argc, char *argv[])
{
    int c;
    short port;
    opterr = 0;
    // getopt()用来分析命令行参数
    //参数 optstring为选项字符串， 告知 getopt()可以处理哪个选项以及哪个选项需要参数
    //如果选项字符串里的字母后接着冒号":"，则表示还有相关的参数,如果接着"::"，则表示选项与参数之间不能有空格。
    //全域变量optarg即会指向此额外参数。
    //如果在处理期间遇到了不符合optstring指定的其他选项getopt()将显示一个错误消息
    //如果不希望getopt()印出错信息，则只要将全域变量opterr设为0即可。
    while ((c = getopt(argc, argv, "l:p::h")) != -1) {
        switch(c) {
            case 'l'://listen
                printf("host:%s\n", optarg);
                break;
            case 'p'://port
                port = atoi(optarg);
                printf("port:%d\n",port);
                break;
            case 'h'://help
                usage();
                exit(0);
            default:
                printf("illegal argument:%c\n",c);
                break;
        }
    }
}


int main(int argc, char *argv[])
{
    ParseOptions(argc, argv);
    return 0;
}

#include <stdio.h>
//是Linux 系统的日期时间头文件。通常会包含include time.h
#include <sys/time.h>
// 是ISO C99 标准日期时间头文件。编写的代码平台无关的需要引入
#include <time.h>

//让函式能够接收不定量参数，va_list需要
#include <stdarg.h>

#define DEBUG 1
#define LOGFILE "write.log"

//编写的代码平台无关的
#define __need_time_t
#define __need_timespec

#define LOG_ERROR 0
#define LOG_NOTICE 1
#define LOG_DEBUG 2
//fmt为格式化字串，如%d%s%c%f
static void WriteLog(int level, const char *fmt, ...)
{
    va_list ap;
    FILE *fp;

#ifdef DEBUG
    fp = stdout;
#else
    fp = fopen(LOGFILE, "a+");
    if (!fp) return;
#endif

    va_start(ap, fmt);
    char *c = "-*+";
    char buf[64];
    time_t now;

    //1970年1月1日00:00:00（称为UNIX系统的Epoch时间）到当前时刻的秒数
    now = time(NULL);
    //gmtime 把日期和时间转换为格林威治(GMT)时间的函数,结果由结构tm返回
    //strftime将tm结构体时间格式化,%d 十进制表示的每月的第几天%b 月分的简写
    strftime(buf, 64, "[%d %b %H:%M:%S]", gmtime(&now));
    //格式化输出到一个流/文件中
    fprintf(fp, "%s %c ", buf, c[level]);
    //格式化输出到一个流/文件中
    int cnt = vfprintf(fp, fmt, ap);
    fprintf(fp, " write %d bite",cnt);
    fprintf(fp, "\n");
    //清除文件缓冲区，文件以写方式打开时将缓冲区内容写入文件
    //fflush(stdout)刷新标准输出缓冲区，把输出缓冲区里的东西打印到标准输出设备上
    fflush(fp);
    va_end(ap);
#ifndef DEBUG
    fclose(fp);
#endif

}
int main(int argc, char *argv[])
{
    WriteLog(LOG_ERROR, "%s %s ","this is a test", "hello world");
    WriteLog(LOG_NOTICE, "%s %s ", "this is a test2", "hello world");
    WriteLog(LOG_DEBUG, "%s %s ", "this is a test3", "hello world");
}

此函数主要是学习va_list和vfprintf和使用，需要注意的是vfprintf传的第二个参数fmt是格式化字符串，而不是其它，刚开始漏传导致第二个参数不能打印。

清理完键盘也同时把风扇也清理了下，才用一年，好多灰啦！！

安速蟑螂屋真的很好用

全景图

特写

不是微距镜头，拍的不是很清，可以看到蟑螂在生命的最后，生出一堆的小蟑螂，生命力顽强呀。

如何用PHP中的Imagick模块来完美实现GIF动画缩略图

<?php

$image = new Imagick('old.gif');

$image = $image->coalesceImages();

foreach ($image as $frame) {
    $frame->thumbnailImage(50, 50);
}

$image = $image->optimizeImageLayers();

$image->writeImages('new.gif', true);

?>

更多内容解释查看原文：http://huoding.com/2010/12/26/32