Socket网络编程--Libev库学习(1)

wget http://dist.schmorp.de/libev/libev-4.15.tar.gz
tar -zxf libev-4.15.tar.gz
cd libev-4.15
./configure
make
make install

Libraries have been installed in:
/usr/local/lib If you ever happen to want to link against installed libraries
in a given directory, LIBDIR, you must either use libtool, and
specify the full pathname of the library, or use the `-LLIBDIR'
flag during linking and do at least one of the following:
- add LIBDIR to the `LD_LIBRARY_PATH' environment variable
during execution
- add LIBDIR to the `LD_RUN_PATH' environment variable
during linking
- use the `-Wl,-rpath -Wl,LIBDIR' linker flag
- have your system administrator add LIBDIR to `/etc/ld.so.conf' See any operating system documentation about shared libraries for
more information, such as the ld() and ld.so() manual pages.
----------------------------------------------------------------------
/bin/mkdir -p '/usr/local/include'
/usr/bin/install -c -m ev.h ev++.h event.h '/usr/local/include'
/bin/mkdir -p '/usr/local/share/man/man3'
/usr/bin/install -c -m ev. '/usr/local/share/man/man3'

#include <stdio.h>
#include <ev.h> //ev库头文件//定义一个ev_TYPE 的结构体
ev_io stdin_watcher;//定义一个stdin的观测者
ev_timer timeout_watcher;//所有的watcher的回调函数都有相似的特点
//当stdin有可读的数据时，将会调用下面这个回调函数
static void stdin_cb(EV_P_ ev_io *w,int revents)
{
puts("stdin ready"); //每一次时间都必须用对应的停止函数，手动的停止其watcher
ev_io_stop(EV_A_ w);
//这将导致所有嵌套执行的ev_run停止监听
ev_break(EV_A_ EVBREAK_ALL);
}//这是一个回调函数，用于定时器回调
static void timeout_cb(EV_P_ ev_timer *w,int revents)
{
puts("timeout");
//这将导致最早运行的ev_run停止监听
ev_break(EV_A_ EVBREAK_ONE);
}int main(int argc,char **args)
{
//使用一般默认的事件循环
struct ev_loop *loop = EV_DEFAULT; //初始化一个I/O watcher，然后启动它
ev_io_init(&stdin_watcher,stdin_cb,,EV_READ);
ev_io_start(loop,&stdin_watcher); //初始化一个定时器watcher，然后启动它，只有一次，没有重复的5.5秒定时
ev_timer_init(&timeout_watcher,timeout_cb,5.5,);
ev_timer_start(loop,&timeout_watcher); //这里等待时间出发
ev_run(loop,); //撤销监听退出程序
return ;
}

export LIBDIR=/usr/local/lib
export LD_LIBRARY_PATH=/usr/local/lib
export LD_RUN_PATH=/usr/local/lib

ev_io stdin_watcher;
ev_timer timeout_watcher; static void stdin_cb(struct ev_loop *loop, ev_io *w,int revents)
{
puts("stdin ready"); ev_io_stop(loop, w); ev_break(loop, EVBREAK_ALL);
} static void timeout_cb(struct ev_loop *loop, ev_timer *w,int revents)
{
puts("timeout"); ev_break(loop, EVBREAK_ONE);
} int main(int argc,char **args)
{ struct ev_loop *loop = ev_default_loop (); do { do { ((ev_watcher *)(void *)((&stdin_watcher)))->active = ((ev_watcher *)(void *)((&stdin_watcher)))->pending = ; ( (ev_watcher *)(void *)(((&stdin_watcher))))->priority = (); (((&stdin_watcher)))->cb = ((stdin_cb)); } while (); do { ((&stdin_watcher))->fd = (()); ((&stdin_watcher))->events = ((EV_READ)) | EV__IOFDSET; } while (); } while ();
ev_io_start(loop,&stdin_watcher); do { do { ((ev_watcher *)(void *)((&timeout_watcher)))->active = ((ev_watcher *)(void *)((&timeout_watcher)))->pending = ; ( (ev_watcher *)(void *)(((&timeout_watcher))))->priority = (); (((&timeout_watcher)))->cb = ((timeout_cb)); } while (); do { ((ev_watcher_time *)((&timeout_watcher)))->at = ((5.5)); ((&timeout_watcher))->repeat = (()); } while (); } while ();
ev_timer_start(loop,&timeout_watcher); ev_run(loop,); return ;
}

do {
do {
((ev_watcher *)(void *)((&stdin_watcher)))->active = ((ev_watcher *)(void *)((&stdin_watcher)))->pending = ;
( (ev_watcher *)(void *)(((&stdin_watcher))))->priority = ();
(((&stdin_watcher)))->cb = ((stdin_cb));
} while ();
do {
((&stdin_watcher))->fd = (());
((&stdin_watcher))->events = ((EV_READ)) | EV__IOFDSET;
} while ();
} while ();
ev_io_start(loop,&stdin_watcher);

#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <sys/unistd.h>
#include <ev.h> void io_action(struct ev_loop *main_loop,ev_io *io_w,int e)
{
int rst;
char buf[];
memset(buf,,sizeof(buf));
puts("In IO action");
read(STDIN_FILENO,buf,sizeof(buf));
buf[]='\0';
printf("String: %s\n",buf);
ev_io_stop(main_loop,io_w);
} void timer_action(struct ev_loop *main_loop,ev_timer *time_w,int e)
{
puts("In Time action");
ev_timer_stop(main_loop,time_w);
} void signal_action(struct ev_loop *main_loop,ev_signal *signal_w,int e)
{
puts("In Signal action");
ev_signal_stop(main_loop,signal_w);
ev_break(main_loop,EVBREAK_ALL);
} int main(int argc,char **argv)
{
ev_io io_w;
ev_timer timer_w;
ev_signal signal_w;
struct ev_loop *main_loop = ev_default_loop(); ev_init(&io_w,io_action);
ev_io_set(&io_w,STDIN_FILENO,EV_READ); ev_init(&timer_w,timer_action);
ev_timer_set(&timer_w,,); ev_init(&signal_w,signal_action);
ev_signal_set(&signal_w,SIGINT); ev_io_start(main_loop,&io_w);
ev_timer_start(main_loop,&timer_w);
ev_signal_start(main_loop,&signal_w); ev_run(main_loop,);
return ;
}

if (!ev_default_loop ())
fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?");
//或者明确选择一个后端：
struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL | EVFLAG_NOENV);
if (!epoller)
fatal ("no epoll found here, maybe it hides under your chair");
//如果需要动态分配循环的话，建议使用 ev_loop_new 和 ev_loop_destroy 。

static void stdin_readable_cb (struct ev_loop *loop, ev_io *w, int revents)
{
ev_io_stop (loop, w);
//.. read from stdin here (or from w->fd) and handle any I/O errors
} ev_io stdin_readable;
ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ);
ev_io_start (loop, &stdin_readable);

static void one_minute_cb (struct ev_loop *loop, ev_timer *w, int revents)
{
//创建一个60秒的计时器
//.. one minute over, w is actually stopped right here
} ev_timer mytimer;
ev_timer_init (&mytimer, one_minute_cb, ., .);
ev_timer_start (loop, &mytimer);

static void timeout_cb (struct ev_loop *loop, ev_timer *w, int revents)
{
//.. ten seconds without any activity
} ev_timer mytimer;
ev_timer_init (&mytimer, timeout_cb, ., .); /* note, only repeat used */
ev_timer_again (&mytimer); /* start timer */
ev_run (loop, ); // and in some piece of code that gets executed on any "activity":
// reset the timeout to start ticking again at 10 seconds
ev_timer_again (&mytimer);

static void clock_cb (struct ev_loop *loop, ev_periodic *w, int revents)
{
// ... its now a full hour (UTC, or TAI or whatever your clock follows)
} ev_periodic hourly_tick;
ev_periodic_init (&hourly_tick, clock_cb, ., ., );
ev_periodic_start (loop, &hourly_tick);

#include <math.h> static ev_tstamp my_scheduler_cb (ev_periodic *w, ev_tstamp now)
{
return now + (. - fmod (now, .));
} ev_periodic_init (&hourly_tick, clock_cb, ., ., my_scheduler_cb);

ev_periodic hourly_tick;
ev_periodic_init (&hourly_tick, clock_cb, fmod (ev_now (loop), .), ., );
ev_periodic_start (loop, &hourly_tick);

static void sigint_cb (struct ev_loop *loop, ev_signal *w, int revents)
{
ev_break (loop, EVBREAK_ALL);
} ev_signal signal_watcher;
ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
ev_signal_start (loop, &signal_watcher);

ev_child cw; static void
child_cb (EV_P_ ev_child *w, int revents)
{
ev_child_stop (EV_A_ w);
printf ("process %d exited with status %x\n", w->rpid, w->rstatus);
} pid_t pid = fork (); if (pid < )
// error
else if (pid == )
{
// the forked child executes here
exit ();
}
else
{
ev_child_init (&cw, child_cb, pid, );
ev_child_start (EV_DEFAULT_ &cw);
}

static void passwd_cb (struct ev_loop *loop, ev_stat *w, int revents)
{
/* /etc/passwd changed in some way */
if (w->attr.st_nlink)
{
printf ("passwd current size %ld\n", (long)w->attr.st_size);
printf ("passwd current atime %ld\n", (long)w->attr.st_mtime);
printf ("passwd current mtime %ld\n", (long)w->attr.st_mtime);
}
else
/* you shalt not abuse printf for puts */
puts ("wow, /etc/passwd is not there, expect problems. if this is windows, they already arrived\n");
} ...
ev_stat passwd; ev_stat_init (&passwd, passwd_cb, "/etc/passwd", .);
ev_stat_start (loop, &passwd);