Apr
11
总赖在学校不走的悲剧就是，别人都毕业工作好久了，你还在蛋疼地写毕设。更蛋疼的是，若是早先毕业的学长们亲切地问起“还在武汉吗？最近做什么呢？”，下一句一般都是，我们来招人啦，帮忙收些简历。
其实代收简历这事儿，早两年就在做了，也算是见过各种形形色色的简历，大牛小牛普通人，当然也不乏二逼青年们。总的来说，大部分人，对简历的概念仅仅局限于下载一份模板并填满这样的程度，实在是让我忍不住不吐槽。当然，吐槽仅限于IT行业相关的简历，隔行如隔山。
首先，网上那些简历模板弱爆了啊亲！又不是让你办入职手续，那些生日民族籍贯户口身高体重地址政治面貌教育背景有个鸟用啊，全TM是废话，而且占用了最重要的位置！更奇葩的是，美女帅哥贴照片增加印象分也就算了，长得很抽象的兄弟姐妹们啊，你们也贴？尤其是那种在宿舍阳台拍了后面还吊一条裤子的，你是来给HR们无聊的时光增添乐趣的吗？那你怎么不穿个比基尼上镜呢！
——建议：如果不是去面试特别正规的国企什么的，别用那些乱七八糟的模板，自己设计一个；不会设计的，则力求简单明了。个人信息包含最基本的姓名、学历(毕业时间)、学校、专业、联系方式外的那些，能省就省了，或者扔到末尾去。除了帅哥美女之外，照片还是别留了。简历一般以1～2页为宜，如果只有一页多一点，就排排版缩到一页；不要搞封面，纯粹浪费生命。
其次，二逼青年们对信息的重要性完全没概念啊！到底申请什么职位啊？发个简历过来就完事儿了？知道申请的这职位要求是啥不？啥都不知道就撂个简历过来，搞毛线啊。申请技术职位，居然把学生工作、课程（成绩）之类毫无意义的内容放在开篇，还写得TM那么详细！申请C/C++开发职位，丫写那么多Java有毛用！项目经历写了几坨却跟没写一样的，根本看不出来丫在项目里做了什么事情、做了多少事情啊！
——建议：写上申请的职位/方向；充分了解职位要求，职位相关的技能、项目经历、获奖放在开篇醒目位置，其余信息放到末尾。项目经历里写清楚自己做了什么事情、多少事情，技术类的项目写清用了什么技术，编码类可以写明自己完成的代码量。申请技术类的职位，学生工作、文娱竞赛、兴趣爱好等信息适当提及就好了。
再次，各种奇葩。找我收简历的都是在B公司、T公司、M公司的同学/学长，希望内推的也要掂量一下自己啊，什么项目经验都没有、什么都不会的简历也发过来，还说“希望贵公司给一个展现的平台、相信我的努力会把工作做好”……这个实在是无力吐槽了。
——建议：在校期间多努力，机会只给有准备的人。
OVER.
其实代收简历这事儿，早两年就在做了，也算是见过各种形形色色的简历，大牛小牛普通人，当然也不乏二逼青年们。总的来说，大部分人，对简历的概念仅仅局限于下载一份模板并填满这样的程度，实在是让我忍不住不吐槽。当然，吐槽仅限于IT行业相关的简历，隔行如隔山。
首先，网上那些简历模板弱爆了啊亲！又不是让你办入职手续，那些生日民族籍贯户口身高体重地址政治面貌教育背景有个鸟用啊，全TM是废话，而且占用了最重要的位置！更奇葩的是，美女帅哥贴照片增加印象分也就算了，长得很抽象的兄弟姐妹们啊，你们也贴？尤其是那种在宿舍阳台拍了后面还吊一条裤子的，你是来给HR们无聊的时光增添乐趣的吗？那你怎么不穿个比基尼上镜呢！
——建议：如果不是去面试特别正规的国企什么的，别用那些乱七八糟的模板，自己设计一个；不会设计的，则力求简单明了。个人信息包含最基本的姓名、学历(毕业时间)、学校、专业、联系方式外的那些，能省就省了，或者扔到末尾去。除了帅哥美女之外，照片还是别留了。简历一般以1～2页为宜，如果只有一页多一点，就排排版缩到一页；不要搞封面，纯粹浪费生命。
其次，二逼青年们对信息的重要性完全没概念啊！到底申请什么职位啊？发个简历过来就完事儿了？知道申请的这职位要求是啥不？啥都不知道就撂个简历过来，搞毛线啊。申请技术职位，居然把学生工作、课程（成绩）之类毫无意义的内容放在开篇，还写得TM那么详细！申请C/C++开发职位，丫写那么多Java有毛用！项目经历写了几坨却跟没写一样的，根本看不出来丫在项目里做了什么事情、做了多少事情啊！
——建议：写上申请的职位/方向；充分了解职位要求，职位相关的技能、项目经历、获奖放在开篇醒目位置，其余信息放到末尾。项目经历里写清楚自己做了什么事情、多少事情，技术类的项目写清用了什么技术，编码类可以写明自己完成的代码量。申请技术类的职位，学生工作、文娱竞赛、兴趣爱好等信息适当提及就好了。
再次，各种奇葩。找我收简历的都是在B公司、T公司、M公司的同学/学长，希望内推的也要掂量一下自己啊，什么项目经验都没有、什么都不会的简历也发过来，还说“希望贵公司给一个展现的平台、相信我的努力会把工作做好”……这个实在是无力吐槽了。
——建议：在校期间多努力，机会只给有准备的人。
OVER.
Apr
8
翻译自：How To Read C Declarations 英文原文
p.s. 以前还真没注意到这篇文章最后提到的vtable是啥意思……
就算是非常有经验的C程序员，也对那些比简单数组/指针更复杂一些的声明感到头疼。比如说，下面这个是一个指针的数组，还是一个数组的指针？
下面这货到底是什么？
当然了，这货是一个指针，指向一个数组，这个数组的每个元素是一个指针，指向一个函数，函数的返回值类型是int :)
这篇短文希望能够教会你一个非常简单地读懂复杂声明的方法。我99%肯定我在80年代读过这篇，但是不记得具体是在什么地方读到的了。我怀疑是我自己发现这个的（尽管我总会被计算机语言结构和神秘的事物搞得很兴奋）。然而我的确记得，能够写出一个程序，将任何声明转换成英语。
== 黄金法则 ==
这个法则是这样说的：
最简单的情况是这样的：
从 i 开始，你向右看，啥都没看到；然后就向左看，看到了int，说出来：i是一个int。
然后看个复杂一点的：
从 a 开始：向右看，说“是一个包含3个元素的数组”；向左看，说“数组的每个元素是指针”；向右看，啥都没；向左看，说“指针指向int”。综合起来就是: a 是一个包含3个元素的数组，每个元素是一个指针，指向int。
加上一对括号让它看起来更怪异点儿：
像在普通表达式中一样，括号改变了阅读/计算的顺序。从 a 开始：向右看，遇到括号了，往回；向左看，说“是一个指针”，遇到(括号，跳出来；向右看，[3]，说“指向一个包含3个元素的数组”；向左看，int，说“数组的每个元素是int”。综合起来：a是一个指针，指向一个包含3个元素的数组，数组的每个元素是一个int。
好，再来看看这个：
赞，你说：foo是一个函数，返回一个指针，指向int。
接下来跳一步：就像我们可以定义一个指向int的指针，我们也可以定义一个指向函数的指针。在这种情况下，不需要extern了（因为不是函数的前向引用声明），而是一个变量的定义。这是一个基本的函数指针：
从foo开始：向右看，遇到括号，往回；向左看，*，说“是一个指针”，遇到左括号，跳出来；向右看，()，说“指向一个函数”；向左看，int，说“函数返回int”。综合起来：foo是一个指针，指向一个函数，函数返回int。
下面是一个数组，每个元素是一个指针，指向函数，函数返回int：
你还需要最后一个，诡异的难以置信的声明：
这是一个指针，指向一个数组，数组的每个元素是个指针，指向一个函数，函数的返回值是int。发现了吗？这货就是上面那个object_vtable的指针，也就是你定义的每一个对象需要的虚函数表(vtable)的指针。
这个指向vtable的指针是一个vtable的地址，例如，&Truck_vtable （就是某个Truck类的实例虚函数表的指针）。
== 总结 ==
接下来的例子总结了所有C++为了实现多态性所建造的虚函数表需要的所有情形（就像最初的C Front - C++转C翻译器）。
p.s. 以前还真没注意到这篇文章最后提到的vtable是啥意思……
就算是非常有经验的C程序员，也对那些比简单数组/指针更复杂一些的声明感到头疼。比如说，下面这个是一个指针的数组，还是一个数组的指针？
int *a[10];
下面这货到底是什么？
int (*(*vtable)[])();
当然了，这货是一个指针，指向一个数组，这个数组的每个元素是一个指针，指向一个函数，函数的返回值类型是int :)
这篇短文希望能够教会你一个非常简单地读懂复杂声明的方法。我99%肯定我在80年代读过这篇，但是不记得具体是在什么地方读到的了。我怀疑是我自己发现这个的（尽管我总会被计算机语言结构和神秘的事物搞得很兴奋）。然而我的确记得，能够写出一个程序，将任何声明转换成英语。
== 黄金法则 ==
这个法则是这样说的：
引用
从标识符开始（或者最内层的结构，如果不存在标识符的话，通常出现于函数指针），首先向右看，直到遇到 ) 括号或者结束，看到什么就说出来；然后向左看，直到遇到 ( 括号或者回到行首，看到什么就说出来。跳出一层括号，重复上述过程：右看看，说出来；左看看，说出来。直到你说出变量的类型或者返回值（针对函数指针），也就表示你把声明都读完了。
最简单的情况是这样的：
int i;
从 i 开始，你向右看，啥都没看到；然后就向左看，看到了int，说出来：i是一个int。
然后看个复杂一点的：
int *a[3];
从 a 开始：向右看，说“是一个包含3个元素的数组”；向左看，说“数组的每个元素是指针”；向右看，啥都没；向左看，说“指针指向int”。综合起来就是: a 是一个包含3个元素的数组，每个元素是一个指针，指向int。
加上一对括号让它看起来更怪异点儿：
int (*a)[3];
像在普通表达式中一样，括号改变了阅读/计算的顺序。从 a 开始：向右看，遇到括号了，往回；向左看，说“是一个指针”，遇到(括号，跳出来；向右看，[3]，说“指向一个包含3个元素的数组”；向左看，int，说“数组的每个元素是int”。综合起来：a是一个指针，指向一个包含3个元素的数组，数组的每个元素是一个int。
好，再来看看这个：
extern int *foo();
赞，你说：foo是一个函数，返回一个指针，指向int。
接下来跳一步：就像我们可以定义一个指向int的指针，我们也可以定义一个指向函数的指针。在这种情况下，不需要extern了（因为不是函数的前向引用声明），而是一个变量的定义。这是一个基本的函数指针：
int (*foo)();
从foo开始：向右看，遇到括号，往回；向左看，*，说“是一个指针”，遇到左括号，跳出来；向右看，()，说“指向一个函数”；向左看，int，说“函数返回int”。综合起来：foo是一个指针，指向一个函数，函数返回int。
下面是一个数组，每个元素是一个指针，指向函数，函数返回int：
int (*Object_vtable[])();
你还需要最后一个，诡异的难以置信的声明：
int (*(*vtable)[])();
这是一个指针，指向一个数组，数组的每个元素是个指针，指向一个函数，函数的返回值是int。发现了吗？这货就是上面那个object_vtable的指针，也就是你定义的每一个对象需要的虚函数表(vtable)的指针。
这个指向vtable的指针是一个vtable的地址，例如，&Truck_vtable （就是某个Truck类的实例虚函数表的指针）。
== 总结 ==
接下来的例子总结了所有C++为了实现多态性所建造的虚函数表需要的所有情形（就像最初的C Front - C++转C翻译器）。
int *ptr_to_int;
int *func_returning_ptr_to_int();
int (*ptr_to_func_returning_int)();
int (*array_of_ptr_to_func_returning_int[])();
int (*(*ptr_to_an_array_of_ptr_to_func_returning_int)[])();
int *func_returning_ptr_to_int();
int (*ptr_to_func_returning_int)();
int (*array_of_ptr_to_func_returning_int[])();
int (*(*ptr_to_an_array_of_ptr_to_func_returning_int)[])();
Mar
23
以前一直纳闷，非特权用户不能编辑 /etc/rc.local ，应该如何实现开机启动任务的功能。。
刚刚详读了下 man 5 crontab ，才知道crontab的前五个参数除了可以用分时日月周之外，
还可以用一些预定义的类型（叫做Vixie cron），其中一个特殊的就是 @reboot ：
也就是说，只要运行crontab -e，加入一行
@reboot /home/username/my_rc.local
就可以实现个人用户的 rc.local 啦！
刚刚详读了下 man 5 crontab ，才知道crontab的前五个参数除了可以用分时日月周之外，
还可以用一些预定义的类型（叫做Vixie cron），其中一个特殊的就是 @reboot ：
引用
Instead of the first five fields, one of eight special strings may appear:
string meaning
------ -------
@reboot Run once, at startup.
@yearly Run once a year, "0 0 1 1 *".
......
string meaning
------ -------
@reboot Run once, at startup.
@yearly Run once a year, "0 0 1 1 *".
......
也就是说，只要运行crontab -e，加入一行
@reboot /home/username/my_rc.local
就可以实现个人用户的 rc.local 啦！
Feb
27
vps在国外，延迟总有那么200～300ms，一来一回，500ms是免不了了。可是默认情况下，你每输入一个字符，ssh客户端（openssh/putty/securecrt）都会发送给服务器，然后服务器将响应返回。
典型ssh情况下是执行命令，比如ls，网络交互是：发送 l 给svr, svr返回 l ，显示 l ，发送 s 给svr，svr返回 s ，显示 s ，发送回车给svr，svr执行 ls ，返回 ls 的输出。也就是说，光输入一个ls命令就至少需要1s+的时间。但如果是要输入一个很复杂的命令，也许还没输入完，你就崩溃了。
采用putty(windows版ok，linux版未测试）内建的Local Echo和Local Line Editing支持，可以部分地解决这个问题：默认配置下，登录以后点击左上角的Putty图标，选择change settings=>Terminal，将Local Echo和Local line editing改成force on，就可以允许你在本地编辑一行命令，按下回车，然后命令才被发送到服务器。结果是服务器接收一整条命令，然后显示一整条命令，然后再输出这条命令的执行结果。
相应的代价就是：
1. 没法使用自动补全和其他bash/readline的快捷键了；
2. 使用vi这类程序的时候，就没法正常编辑了，这时需要再把这两个选项关闭。。。（为什么没有快捷键………………）
典型ssh情况下是执行命令，比如ls，网络交互是：发送 l 给svr, svr返回 l ，显示 l ，发送 s 给svr，svr返回 s ，显示 s ，发送回车给svr，svr执行 ls ，返回 ls 的输出。也就是说，光输入一个ls命令就至少需要1s+的时间。但如果是要输入一个很复杂的命令，也许还没输入完，你就崩溃了。
采用putty(windows版ok，linux版未测试）内建的Local Echo和Local Line Editing支持，可以部分地解决这个问题：默认配置下，登录以后点击左上角的Putty图标，选择change settings=>Terminal，将Local Echo和Local line editing改成force on，就可以允许你在本地编辑一行命令，按下回车，然后命令才被发送到服务器。结果是服务器接收一整条命令，然后显示一整条命令，然后再输出这条命令的执行结果。
相应的代价就是：
1. 没法使用自动补全和其他bash/readline的快捷键了；
2. 使用vi这类程序的时候，就没法正常编辑了，这时需要再把这两个选项关闭。。。（为什么没有快捷键………………）
Feb
26
数据存在别人那里，总还是不太放心，再加上uyan用起来效果并没有预期那么好，所以决定回归boblog的原始评论系统。
早料到有这么一天的，不过uyan没有提供迁移评论数据的接口，只能自己动手了。
打开chrome的开发人员工具->Network，登录uyan.cc的管理首页，可以看到对 http://uyan.cc/index.php/youyan_admin/getMoreCommentsByDomain/0 的请求，也就是所有通过uyan的评论。把response拷贝出来，大概处理一下，每行一个json object这样，并根据comment_id进行排序（比如 sort -nk4 -t\" replies.php > replies_sorted.txt），然后用一个php脚本转换成对应的sql，最后通过mysql commandline的source命令导入，搞定。
p.s. 刚刚又加了几行代码到 inc/securitycode.php ，把原来的验证码改成表达式格式了，嘿嘿，希望垃圾评论会减少啦～
pps. 又加了几行代码，对评论的回复会有邮件通知啦~
php代码大致如下：
早料到有这么一天的，不过uyan没有提供迁移评论数据的接口，只能自己动手了。
打开chrome的开发人员工具->Network，登录uyan.cc的管理首页，可以看到对 http://uyan.cc/index.php/youyan_admin/getMoreCommentsByDomain/0 的请求，也就是所有通过uyan的评论。把response拷贝出来，大概处理一下，每行一个json object这样，并根据comment_id进行排序（比如 sort -nk4 -t\" replies.php > replies_sorted.txt），然后用一个php脚本转换成对应的sql，最后通过mysql commandline的source命令导入，搞定。
p.s. 刚刚又加了几行代码到 inc/securitycode.php ，把原来的验证码改成表达式格式了，嘿嘿，希望垃圾评论会减少啦～
pps. 又加了几行代码，对评论的回复会有邮件通知啦~
php代码大致如下：
Feb
25
花了两天的时间在libevent上，想总结下，就以写简单tutorial的方式吧，貌似没有一篇简单的说明，让人马上就能上手用的。
首先给出官方文档吧： http://libevent.org ，首页有个Programming with Libevent，里面是一节一节的介绍libevent，但是感觉信息量太大了，而且还是英文的-。-（当然，如果想好好用libevent，看看还是很有必要的），还有个Reference，大致就是对各个版本的libevent使用doxgen生成的文档，用来查函数原型和基本用法什么的。
下面假定已经学习过基本的socket编程（socket,bind,listen,accept,connect,recv,send,close），并且对异步/callback有基本认识。
基本的socket编程是阻塞/同步的，每个操作除非已经完成或者出错才会返回，这样对于每一个请求，要使用一个线程或者单独的进程去处理，系统资源没法支撑大量的请求（所谓c10k problem），例如内存(默认情况下每个线程需要占用2～8M的栈空间)，以及进程切换带来的原因等。posix定义了可以使用异步的select系统调用，但是因为其采用了轮询的方式来判断某个fd是否变成active，效率不高[O(n)]，连接数一多，也还是撑不住。于是各系统分别提出了基于异步/callback的系统调用，例如Linux的epoll，BSD的kqueue，Windows的IOCP。由于在内核层面做了支持，所以可以用O(1)的效率查找到active的fd。基本上，libevent就是对这些高效IO的封装，提供统一的API，简化开发。
libevent大概是这样的：
默认情况下是单线程的（可以配置成多线程，如果有需要的话），每个线程有且只有一个event_base，对应一个struct event_base结构体（以及附于其上的事件管理器），用来schedule托管给它的一系列event，可以和操作系统的进程管理类比，当然，要更简单一点。当一个事件发生后，event_base会在合适的时间（不一定是立即）去调用绑定在这个事件上的函数（传入一些预定义的参数，以及在绑定时指定的一个参数），直到这个函数执行完，再返回schedule其他事件。
event_base内部有一个循环，循环阻塞在epoll/kqueue等系统调用上，直到有一个/一些事件发生，然后去处理这些事件。当然，这些事件要被绑定在这个event_base上。每个事件对应一个struct event，可以是监听一个fd或者POSIX信号量之类（这里只讲fd了，其他的看manual吧）。struct event使用event_new来创建和绑定，使用event_add来启用：
注：libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)
(a) EV_TIMEOUT: 超时
(b) EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发
(c) EV_WRITE: 只要塞给网络缓冲的数据被写完，回调函数就会被触发
(d) EV_SIGNAL: POSIX信号量，参考manual吧
(e) EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除
(f) EV_ET: Edge-Trigger边缘触发，参考EPOLL_ET
然后需要启动event_base的循环，这样才能开始处理发生的事件。循环的启动使用event_base_dispatch，循环将一直持续，直到不再有需要关注的事件，或者是遇到event_loopbreak()/event_loopexit()函数。
接下来关注下绑定到event的回调函数callback_func：传递给它的是一个socket fd、一个event类型及属性bit_field、以及传递给event_new的最后一个参数（去上面几行回顾一下，把event_base给传进来了，实际上更多地是分配一个结构体，把相关的数据都撂进去，然后丢给event_new，在这里就能取得到了）。其原型是：
对于一个服务器而言，上面的流程大概是这样组合的：
1. listener = socket()，bind()，listen()，设置nonblocking(POSIX系统中可使用fcntl设置，windows不需要设置，实际上libevent提供了统一的包装evutil_make_socket_nonblocking)
2. 创建一个event_base
3. 创建一个event，将该socket托管给event_base，指定要监听的事件类型，并绑定上相应的回调函数(及需要给它的参数)。对于listener socket来说，只需要监听EV_READ|EV_PERSIST
4. 启用该事件
5. 进入事件循环
---------------
6. (异步) 当有client发起请求的时候，调用该回调函数，进行处理。
问题：为什么不在listen完马上调用accept，获得客户端连接以后再丢给event_base呢？这个问题先想想噢。
回调函数要做什么事情呢？当然是处理client的请求了。首先要accept，获得一个可以与client通信的sockfd，然后……调用recv/send吗？错！大错特错！如果直接调用recv/send的话，这个线程就阻塞在这个地方了，如果这个客户端非常的阴险（比如一直不发消息，或者网络不好，老是丢包），libevent就只能等它，没法处理其他的请求了——所以应该创建一个新的event来托管这个sockfd。
在老版本libevent上的实现，比较罗嗦[如果不想详细了解的话，看下一部分]。
对于服务器希望先从client获取数据的情况，大致流程是这样的：
1. 将这个sockfd设置为nonblocking
2. 创建2个event:
event_read，绑上sockfd的EV_READ|EV_PERSIST，设置回调函数和参数（后面提到的struct）
event_write，绑上sockfd的EV_WRITE|EV_PERSIST，设置回调函数和参数（后面提到的struct）
3. 启用event_read事件
------
4. (异步) 等待event_read事件的发生, 调用相应的回调函数。这里麻烦来了：回调函数用recv读入的数据，不能直接用send丢给sockfd了事——因为sockfd是nonblocking的，丢给它的话，不能保证正确（为什么呢？）。所以需要一个自己管理的缓存用来保存读入的数据中（在accept以后就创建一个struct，作为第2步回调函数的arg传进来），在合适的时间（比如遇到换行符）启用event_write事件【event_add(event_write, NULL)】，等待EV_WRITE事件的触发
------
5. (异步) 当event_write事件的回调函数被调用的时候，往sockfd写入数据，然后删除event_write事件【event_del(event_write)】，等待event_read事件的下一次执行。
以上步骤比较晦涩，具体代码可参考官方文档里面的【Example: A low-level ROT13 server with Libevent】
由于需要自己管理缓冲区，且过程晦涩难懂，并且不兼容于Windows的IOCP，所以libevent2开始，提供了bufferevent这个神器，用来提供更加优雅、易用的API。struct bufferevent内建了两个event(read/write)和对应的缓冲区【struct evbuffer *input, *output】，并提供相应的函数用来操作缓冲区（或者直接操作bufferevent）。每当有数据被读入input的时候，read_cb函数被调用；每当output被输出完的时候，write_cb被调用；在网络IO操作出现错误的情况（连接中断、超时、其他错误），error_cb被调用。于是上一部分的步骤被简化为：
1. 设置sockfd为nonblocking
2. 使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base
3. 使用bufferevent_setcb(bev, read_cb, write_cb, error_cb, (void *)arg)将EV_READ/EV_WRITE对应的函数
4. 使用bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST)来启用read/write事件
------
5. (异步)
在read_cb里面从input读取数据，处理完毕后塞到output里(会被自动写入到sockfd)
在write_cb里面（需要做什么吗？对于一个echo server来说，read_cb就足够了）
在error_cb里面处理遇到的错误
*. 可以使用bufferevent_set_timeouts(bev, struct timeval *READ, struct timeval *WRITE)来设置读写超时, 在error_cb里面处理超时。
*. read_cb和write_cb的原型是
void read_or_write_callback(struct bufferevent *bev, void *arg)
error_cb的原型是
void error_cb(struct bufferevent *bev, short error, void *arg) //这个是event的标准回调函数原型
可以从bev中用libevent的API提取出event_base、sockfd、input/output等相关数据，详情RTFM~
于是代码简化到只需要几行的read_cb和error_cb函数即可：
于是一个支持大并发量的echo server就成型了！下面附上无注释的echo server源码，110行，多抄几遍，就能完全弄懂啦！更复杂的例子参见官方文档里面的【Example: A simpler ROT13 server with Libevent】
首先给出官方文档吧： http://libevent.org ，首页有个Programming with Libevent，里面是一节一节的介绍libevent，但是感觉信息量太大了，而且还是英文的-。-（当然，如果想好好用libevent，看看还是很有必要的），还有个Reference，大致就是对各个版本的libevent使用doxgen生成的文档，用来查函数原型和基本用法什么的。
下面假定已经学习过基本的socket编程（socket,bind,listen,accept,connect,recv,send,close），并且对异步/callback有基本认识。
基本的socket编程是阻塞/同步的，每个操作除非已经完成或者出错才会返回，这样对于每一个请求，要使用一个线程或者单独的进程去处理，系统资源没法支撑大量的请求（所谓c10k problem），例如内存(默认情况下每个线程需要占用2～8M的栈空间)，以及进程切换带来的原因等。posix定义了可以使用异步的select系统调用，但是因为其采用了轮询的方式来判断某个fd是否变成active，效率不高[O(n)]，连接数一多，也还是撑不住。于是各系统分别提出了基于异步/callback的系统调用，例如Linux的epoll，BSD的kqueue，Windows的IOCP。由于在内核层面做了支持，所以可以用O(1)的效率查找到active的fd。基本上，libevent就是对这些高效IO的封装，提供统一的API，简化开发。
libevent大概是这样的：
默认情况下是单线程的（可以配置成多线程，如果有需要的话），每个线程有且只有一个event_base，对应一个struct event_base结构体（以及附于其上的事件管理器），用来schedule托管给它的一系列event，可以和操作系统的进程管理类比，当然，要更简单一点。当一个事件发生后，event_base会在合适的时间（不一定是立即）去调用绑定在这个事件上的函数（传入一些预定义的参数，以及在绑定时指定的一个参数），直到这个函数执行完，再返回schedule其他事件。
//创建一个event_base
struct event_base *base = event_base_new();
assert(base != NULL);
struct event_base *base = event_base_new();
assert(base != NULL);
event_base内部有一个循环，循环阻塞在epoll/kqueue等系统调用上，直到有一个/一些事件发生，然后去处理这些事件。当然，这些事件要被绑定在这个event_base上。每个事件对应一个struct event，可以是监听一个fd或者POSIX信号量之类（这里只讲fd了，其他的看manual吧）。struct event使用event_new来创建和绑定，使用event_add来启用：
//创建并绑定一个event
struct event *listen_event;
//参数：event_base, 监听的fd，事件类型及属性，绑定的回调函数，给回调函数的参数
listen_event = event_new(base, listener, EV_READ|EV_PERSIST, callback_func, (void*)base);
//参数：event，超时时间(struct timeval *类型的，NULL表示无超时设置)
event_add(listen_event, NULL);
struct event *listen_event;
//参数：event_base, 监听的fd，事件类型及属性，绑定的回调函数，给回调函数的参数
listen_event = event_new(base, listener, EV_READ|EV_PERSIST, callback_func, (void*)base);
//参数：event，超时时间(struct timeval *类型的，NULL表示无超时设置)
event_add(listen_event, NULL);
注：libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)
(a) EV_TIMEOUT: 超时
(b) EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发
(c) EV_WRITE: 只要塞给网络缓冲的数据被写完，回调函数就会被触发
(d) EV_SIGNAL: POSIX信号量，参考manual吧
(e) EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除
(f) EV_ET: Edge-Trigger边缘触发，参考EPOLL_ET
然后需要启动event_base的循环，这样才能开始处理发生的事件。循环的启动使用event_base_dispatch，循环将一直持续，直到不再有需要关注的事件，或者是遇到event_loopbreak()/event_loopexit()函数。
//启动事件循环
event_base_dispatch(base);
event_base_dispatch(base);
接下来关注下绑定到event的回调函数callback_func：传递给它的是一个socket fd、一个event类型及属性bit_field、以及传递给event_new的最后一个参数（去上面几行回顾一下，把event_base给传进来了，实际上更多地是分配一个结构体，把相关的数据都撂进去，然后丢给event_new，在这里就能取得到了）。其原型是：
typedef void(* event_callback_fn)(evutil_socket_t sockfd, short event_type, void *arg)
对于一个服务器而言，上面的流程大概是这样组合的：
1. listener = socket()，bind()，listen()，设置nonblocking(POSIX系统中可使用fcntl设置，windows不需要设置，实际上libevent提供了统一的包装evutil_make_socket_nonblocking)
2. 创建一个event_base
3. 创建一个event，将该socket托管给event_base，指定要监听的事件类型，并绑定上相应的回调函数(及需要给它的参数)。对于listener socket来说，只需要监听EV_READ|EV_PERSIST
4. 启用该事件
5. 进入事件循环
---------------
6. (异步) 当有client发起请求的时候，调用该回调函数，进行处理。
问题：为什么不在listen完马上调用accept，获得客户端连接以后再丢给event_base呢？这个问题先想想噢。
回调函数要做什么事情呢？当然是处理client的请求了。首先要accept，获得一个可以与client通信的sockfd，然后……调用recv/send吗？错！大错特错！如果直接调用recv/send的话，这个线程就阻塞在这个地方了，如果这个客户端非常的阴险（比如一直不发消息，或者网络不好，老是丢包），libevent就只能等它，没法处理其他的请求了——所以应该创建一个新的event来托管这个sockfd。
在老版本libevent上的实现，比较罗嗦[如果不想详细了解的话，看下一部分]。
对于服务器希望先从client获取数据的情况，大致流程是这样的：
1. 将这个sockfd设置为nonblocking
2. 创建2个event:
event_read，绑上sockfd的EV_READ|EV_PERSIST，设置回调函数和参数（后面提到的struct）
event_write，绑上sockfd的EV_WRITE|EV_PERSIST，设置回调函数和参数（后面提到的struct）
3. 启用event_read事件
------
4. (异步) 等待event_read事件的发生, 调用相应的回调函数。这里麻烦来了：回调函数用recv读入的数据，不能直接用send丢给sockfd了事——因为sockfd是nonblocking的，丢给它的话，不能保证正确（为什么呢？）。所以需要一个自己管理的缓存用来保存读入的数据中（在accept以后就创建一个struct，作为第2步回调函数的arg传进来），在合适的时间（比如遇到换行符）启用event_write事件【event_add(event_write, NULL)】，等待EV_WRITE事件的触发
------
5. (异步) 当event_write事件的回调函数被调用的时候，往sockfd写入数据，然后删除event_write事件【event_del(event_write)】，等待event_read事件的下一次执行。
以上步骤比较晦涩，具体代码可参考官方文档里面的【Example: A low-level ROT13 server with Libevent】
由于需要自己管理缓冲区，且过程晦涩难懂，并且不兼容于Windows的IOCP，所以libevent2开始，提供了bufferevent这个神器，用来提供更加优雅、易用的API。struct bufferevent内建了两个event(read/write)和对应的缓冲区【struct evbuffer *input, *output】，并提供相应的函数用来操作缓冲区（或者直接操作bufferevent）。每当有数据被读入input的时候，read_cb函数被调用；每当output被输出完的时候，write_cb被调用；在网络IO操作出现错误的情况（连接中断、超时、其他错误），error_cb被调用。于是上一部分的步骤被简化为：
1. 设置sockfd为nonblocking
2. 使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base
3. 使用bufferevent_setcb(bev, read_cb, write_cb, error_cb, (void *)arg)将EV_READ/EV_WRITE对应的函数
4. 使用bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST)来启用read/write事件
------
5. (异步)
在read_cb里面从input读取数据，处理完毕后塞到output里(会被自动写入到sockfd)
在write_cb里面（需要做什么吗？对于一个echo server来说，read_cb就足够了）
在error_cb里面处理遇到的错误
*. 可以使用bufferevent_set_timeouts(bev, struct timeval *READ, struct timeval *WRITE)来设置读写超时, 在error_cb里面处理超时。
*. read_cb和write_cb的原型是
void read_or_write_callback(struct bufferevent *bev, void *arg)
error_cb的原型是
void error_cb(struct bufferevent *bev, short error, void *arg) //这个是event的标准回调函数原型
可以从bev中用libevent的API提取出event_base、sockfd、input/output等相关数据，详情RTFM~
于是代码简化到只需要几行的read_cb和error_cb函数即可：
void read_cb(struct bufferevent *bev, void *arg) {
char line[256];
int n;
evutil_socket_t fd = bufferevent_getfd(bev);
while (n = bufferevent_read(bev, line, 256), n > 0)
bufferevent_write(bev, line, n);
}
void error_cb(struct bufferevent *bev, short event, void *arg) {
bufferevent_free(bev);
}
char line[256];
int n;
evutil_socket_t fd = bufferevent_getfd(bev);
while (n = bufferevent_read(bev, line, 256), n > 0)
bufferevent_write(bev, line, n);
}
void error_cb(struct bufferevent *bev, short event, void *arg) {
bufferevent_free(bev);
}
于是一个支持大并发量的echo server就成型了！下面附上无注释的echo server源码，110行，多抄几遍，就能完全弄懂啦！更复杂的例子参见官方文档里面的【Example: A simpler ROT13 server with Libevent】
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#define LISTEN_PORT 9999
#define LISTEN_BACKLOG 32
void do_accept(evutil_socket_t listener, short event, void *arg);
void read_cb(struct bufferevent *bev, void *arg);
void error_cb(struct bufferevent *bev, short event, void *arg);
void write_cb(struct bufferevent *bev, void *arg);
int main(int argc, char *argv[])
{
int ret;
evutil_socket_t listener;
listener = socket(AF_INET, SOCK_STREAM, 0);
assert(listener > 0);
evutil_make_listen_socket_reuseable(listener);
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons(LISTEN_PORT);
if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("bind");
return 1;
}
if (listen(listener, LISTEN_BACKLOG) < 0) {
perror("listen");
return 1;
}
printf ("Listening...\n");
evutil_make_socket_nonblocking(listener);
struct event_base *base = event_base_new();
assert(base != NULL);
struct event *listen_event;
listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
event_add(listen_event, NULL);
event_base_dispatch(base);
printf("The End.");
return 0;
}
void do_accept(evutil_socket_t listener, short event, void *arg)
{
struct event_base *base = (struct event_base *)arg;
evutil_socket_t fd;
struct sockaddr_in sin;
socklen_t slen = sizeof(sin);
fd = accept(listener, (struct sockaddr *)&sin, &slen);
if (fd < 0) {
perror("accept");
return;
}
if (fd > FD_SETSIZE) { //这个if是参考了那个ROT13的例子，貌似是官方的疏漏，从select-based例子里抄过来忘了改
perror("fd > FD_SETSIZE\n");
return;
}
printf("ACCEPT: fd = %u\n", fd);
struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(bev, read_cb, NULL, error_cb, arg);
bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST);
}
void read_cb(struct bufferevent *bev, void *arg)
{
#define MAX_LINE 256
char line[MAX_LINE+1];
int n;
evutil_socket_t fd = bufferevent_getfd(bev);
while (n = bufferevent_read(bev, line, MAX_LINE), n > 0) {
line[n] = '\0';
printf("fd=%u, read line: %s\n", fd, line);
bufferevent_write(bev, line, n);
}
}
void write_cb(struct bufferevent *bev, void *arg) {}
void error_cb(struct bufferevent *bev, short event, void *arg)
{
evutil_socket_t fd = bufferevent_getfd(bev);
printf("fd = %u, ", fd);
if (event & BEV_EVENT_TIMEOUT) {
printf("Timed out\n"); //if bufferevent_set_timeouts() called
}
else if (event & BEV_EVENT_EOF) {
printf("connection closed\n");
}
else if (event & BEV_EVENT_ERROR) {
printf("some other error\n");
}
bufferevent_free(bev);
}
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#define LISTEN_PORT 9999
#define LISTEN_BACKLOG 32
void do_accept(evutil_socket_t listener, short event, void *arg);
void read_cb(struct bufferevent *bev, void *arg);
void error_cb(struct bufferevent *bev, short event, void *arg);
void write_cb(struct bufferevent *bev, void *arg);
int main(int argc, char *argv[])
{
int ret;
evutil_socket_t listener;
listener = socket(AF_INET, SOCK_STREAM, 0);
assert(listener > 0);
evutil_make_listen_socket_reuseable(listener);
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons(LISTEN_PORT);
if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("bind");
return 1;
}
if (listen(listener, LISTEN_BACKLOG) < 0) {
perror("listen");
return 1;
}
printf ("Listening...\n");
evutil_make_socket_nonblocking(listener);
struct event_base *base = event_base_new();
assert(base != NULL);
struct event *listen_event;
listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
event_add(listen_event, NULL);
event_base_dispatch(base);
printf("The End.");
return 0;
}
void do_accept(evutil_socket_t listener, short event, void *arg)
{
struct event_base *base = (struct event_base *)arg;
evutil_socket_t fd;
struct sockaddr_in sin;
socklen_t slen = sizeof(sin);
fd = accept(listener, (struct sockaddr *)&sin, &slen);
if (fd < 0) {
perror("accept");
return;
}
if (fd > FD_SETSIZE) { //这个if是参考了那个ROT13的例子，貌似是官方的疏漏，从select-based例子里抄过来忘了改
perror("fd > FD_SETSIZE\n");
return;
}
printf("ACCEPT: fd = %u\n", fd);
struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(bev, read_cb, NULL, error_cb, arg);
bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST);
}
void read_cb(struct bufferevent *bev, void *arg)
{
#define MAX_LINE 256
char line[MAX_LINE+1];
int n;
evutil_socket_t fd = bufferevent_getfd(bev);
while (n = bufferevent_read(bev, line, MAX_LINE), n > 0) {
line[n] = '\0';
printf("fd=%u, read line: %s\n", fd, line);
bufferevent_write(bev, line, n);
}
}
void write_cb(struct bufferevent *bev, void *arg) {}
void error_cb(struct bufferevent *bev, short event, void *arg)
{
evutil_socket_t fd = bufferevent_getfd(bev);
printf("fd = %u, ", fd);
if (event & BEV_EVENT_TIMEOUT) {
printf("Timed out\n"); //if bufferevent_set_timeouts() called
}
else if (event & BEV_EVENT_EOF) {
printf("connection closed\n");
}
else if (event & BEV_EVENT_ERROR) {
printf("some other error\n");
}
bufferevent_free(bev);
}
Feb
24
上一篇TCP Port Multiplexing提到，proxy_connect模块貌似不能限制被代理的HOST。也就是说，通过这台服务器可以PROXY到任意机器这样是有风险的。可是mod_proxy模块又没有提供专门的配置来限制可代理的HOST，所以只好舍近求远写了个multiplexer。
实际上要解决这个问题也是很简单的，可以想到，知道找到相应的地方，直接修改源码，只需要几行就行。虽然以前没有搞过apache的module，但是跟php的也比较类似了。看了下代码发现，前文的“貌似”两个字可以去掉了，的确没有什么地方限制了可代理的HOST。
在Ubuntu下尤其简单：（假定已经配置好了mod_proxy/mod_proxy_connect，比如AllowConnect 22、ProxyRequests On什么的）
添加如下几行：
保存后，执行
然后再试试看？
实际上要解决这个问题也是很简单的，可以想到，知道找到相应的地方，直接修改源码，只需要几行就行。虽然以前没有搞过apache的module，但是跟php的也比较类似了。看了下代码发现，前文的“貌似”两个字可以去掉了，的确没有什么地方限制了可代理的HOST。
在Ubuntu下尤其简单：（假定已经配置好了mod_proxy/mod_proxy_connect，比如AllowConnect 22、ProxyRequests On什么的）
引用
$ apt-get source apache2
$ cd apache2-2.2.14/modules/proxy
$ vi mod_proxy_connect.c +123 #就是打开123行，这里刚从http请求里分离出HOST
$ cd apache2-2.2.14/modules/proxy
$ vi mod_proxy_connect.c +123 #就是打开123行，这里刚从http请求里分离出HOST
添加如下几行：
char *allowed_hosts[] = {
"SOME_HOST_NAME",
"SOME_IP",
"127.0.0.1",
"localhost"
};
int hosts_num = sizeof(allowed_hosts) / sizeof(allowed_hosts[0]);
int k;
for (k = 0; k < hosts_num; k++) {
if (strncmp(uri.hostname, allowed_hosts[k], strlen(allowed_hosts[k])) == 0) {
break;
}
}
if (k == hosts_num) {
return ap_proxyerror(r, HTTP_BAD_GATEWAY,
apr_pstrcat(p, "host not allowed for: ", uri.hostname, NULL));
}
"SOME_HOST_NAME",
"SOME_IP",
"127.0.0.1",
"localhost"
};
int hosts_num = sizeof(allowed_hosts) / sizeof(allowed_hosts[0]);
int k;
for (k = 0; k < hosts_num; k++) {
if (strncmp(uri.hostname, allowed_hosts[k], strlen(allowed_hosts[k])) == 0) {
break;
}
}
if (k == hosts_num) {
return ap_proxyerror(r, HTTP_BAD_GATEWAY,
apr_pstrcat(p, "host not allowed for: ", uri.hostname, NULL));
}
保存后，执行
引用
$ sudo apt-get install apache2-dev
$ apxs2 -c mod_proxy_connect.c proxy_util.c
$ cp .libs/mod_proxy_connect.so /usr/lib/apache2/modules #这里会覆盖现有的，最好备份一下
$ sudo /etc/init.d/apache2 restart
$ apxs2 -c mod_proxy_connect.c proxy_util.c
$ cp .libs/mod_proxy_connect.so /usr/lib/apache2/modules #这里会覆盖现有的，最好备份一下
$ sudo /etc/init.d/apache2 restart
然后再试试看？
Feb
24
很久很久以前就想过这个问题，是不是可以写这样一个frontend proxy，通过client的请求来判断需要连接的端口号，实现http/ssh共用80端口呢？
不久后我发现，通过apache的mod_proxy+mod_proxy_connect可以使用HTTP的CONNECT HOST:PORT命令来代理22端口，也就是tunneling ssh over http, google可以发现很多都用到了proxytunnel，当作openssh client的代理；securecrt内建支持，使用Option->Global里面的firewall，其实就是proxy。
于是这个想法被搁置了，好几年。为什么又想起了呢…………是因为，proxy_connect模块貌似不能限制被代理的HOST。也就是说，通过这台服务器可以PROXY到任意机器这样是有风险的。
于是昨天花了半个下午+半个晚上看libevent的文档。其实本来是打算找个速成教程的，但是好像没有，所以还是老老实实看文档。当天晚上写出了第一个版本的multiplexer，各种BUG。无奈，第二天干脆推倒重来，写了第二个版本，还是各种BUG。各种蛋疼之后，终于实现了一个基本可用的multiplexer，250行左右，挺短的代码。
遇到的主要障碍包括：
1. bufferevent *bev的read_cb函数被调用以后，应该用一个while循环把bev里面所有的数据都读出来（比如使用bufferevent_read）；
2. set_nonblocking的操作应该在bind/listen/connect等操作之后完成；否则这些操作也是nonblocking了……
3. 最好加上 |EV_PERSIST ，免得每次callback的时候都要再enable或者add一次；
4. ssh协议对client/server哪个先说话貌似没要求，比如openssh是等server先说话，而securecrt是自己先说话，所以这个multiplexer的实现很蛋疼，需要设置一个timeout，如果client过了一会儿没说话，就forward给sshd。
5. 对于4，更蛋疼的是，（我用的libevent2.0.17-stable）bufferevent_set_timeouts(bev, NULL, NULL)貌似不能清除timeout（或许是个BUG?），所以使用了一个struct timeval tv = {86400*1024, 0} 来绕过timeout的问题。
大概就这些，代码如下
不久后我发现，通过apache的mod_proxy+mod_proxy_connect可以使用HTTP的CONNECT HOST:PORT命令来代理22端口，也就是tunneling ssh over http, google可以发现很多都用到了proxytunnel，当作openssh client的代理；securecrt内建支持，使用Option->Global里面的firewall，其实就是proxy。
于是这个想法被搁置了，好几年。为什么又想起了呢…………是因为，proxy_connect模块貌似不能限制被代理的HOST。也就是说，通过这台服务器可以PROXY到任意机器这样是有风险的。
于是昨天花了半个下午+半个晚上看libevent的文档。其实本来是打算找个速成教程的，但是好像没有，所以还是老老实实看文档。当天晚上写出了第一个版本的multiplexer，各种BUG。无奈，第二天干脆推倒重来，写了第二个版本，还是各种BUG。各种蛋疼之后，终于实现了一个基本可用的multiplexer，250行左右，挺短的代码。
遇到的主要障碍包括：
1. bufferevent *bev的read_cb函数被调用以后，应该用一个while循环把bev里面所有的数据都读出来（比如使用bufferevent_read）；
2. set_nonblocking的操作应该在bind/listen/connect等操作之后完成；否则这些操作也是nonblocking了……
3. 最好加上 |EV_PERSIST ，免得每次callback的时候都要再enable或者add一次；
4. ssh协议对client/server哪个先说话貌似没要求，比如openssh是等server先说话，而securecrt是自己先说话，所以这个multiplexer的实现很蛋疼，需要设置一个timeout，如果client过了一会儿没说话，就forward给sshd。
5. 对于4，更蛋疼的是，（我用的libevent2.0.17-stable）bufferevent_set_timeouts(bev, NULL, NULL)貌似不能清除timeout（或许是个BUG?），所以使用了一个struct timeval tv = {86400*1024, 0} 来绕过timeout的问题。
大概就这些，代码如下
