int
main() {
pipe(pp);
struct event_base *base = event_base_new();
evr = event_new(base, pp[0], EV_READ, read_cb, NULL);
evw = event_new(base, pp[1], EV_WRITE | EV_TIMEOUT, write_cb, NULL);
event_add(evw, NULL);
event_add(evr, NULL);
struct event_base *outbase;
int fdout;
event_get_assignment(evw, NULL, &fdout, NULL, NULL, NULL); /* Note fdout. */
outbase = event_get_base(evw); /* outbase == base */
event_callback_fn cb = event_get_callback(evw);
assert(write_cb == cb);
assert(NULL == event_get_callback_arg(evw));
assert(EV_WRITE|EV_TIMEOUT == event_get_events(evw));
assert(pp[1] == event_get_fd(evw));
assert(event_initialized(evw) == 1);
test_num_events();
event_base_dispatch(base);
return 0;
}
static struct event_base *
event_listener_getbase(struct evconnlistener *lev)
{
struct evconnlistener_event *lev_e =
EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
return event_get_base(&lev_e->listener);
}
void ts_socks5_relay(struct ts_session *session) {
session->rtoc = event_new(event_get_base(session->ctor), session->client->fd,
EV_WRITE, ts_response_method, session);
if (event_add(session->rtoc, NULL) < 0) {
ts_session_close(session);
}
}
gboolean
rspamd_redis_process_tokens (struct rspamd_task *task,
GPtrArray *tokens,
gint id, gpointer p)
{
struct redis_stat_runtime *rt = REDIS_RUNTIME (p);
rspamd_fstring_t *query;
struct timeval tv;
gint ret;
if (tokens == NULL || tokens->len == 0 || rt->redis == NULL) {
return FALSE;
}
rt->id = id;
if (redisAsyncCommand (rt->redis, rspamd_redis_connected, rt, "HGET %s %s",
rt->redis_object_expanded, "learns") == REDIS_OK) {
rspamd_session_add_event (task->s, rspamd_redis_fin, rt,
rspamd_redis_stat_quark ());
rt->has_event = TRUE;
if (event_get_base (&rt->timeout_event)) {
event_del (&rt->timeout_event);
}
event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_timeout, rt);
event_base_set (task->ev_base, &rt->timeout_event);
double_to_tv (rt->ctx->timeout, &tv);
event_add (&rt->timeout_event, &tv);
query = rspamd_redis_tokens_to_query (task, tokens,
"HMGET", rt->redis_object_expanded, FALSE, -1,
rt->stcf->clcf->flags & RSPAMD_FLAG_CLASSIFIER_INTEGER);
g_assert (query != NULL);
rspamd_mempool_add_destructor (task->task_pool,
(rspamd_mempool_destruct_t)rspamd_fstring_free, query);
ret = redisAsyncFormattedCommand (rt->redis, rspamd_redis_processed, rt,
query->str, query->len);
if (ret == REDIS_OK) {
return TRUE;
}
else {
msg_err_task ("call to redis failed: %s", rt->redis->errstr);
}
}
return FALSE;
}
static void sig_act(evutil_socket_t fd, short events, void *arg)
{
// printf("sig_act pid:%d subpid:%d sig:%d base:%p\n ",getpid(),strTag->pid,events,strTag->base);
// printf("kill %d !!!\n",kill(strTag->pid,SIGUSR1));
// event_base_loopexit(event_get_base(arg),NULL);
// event_base_loopbreak(strTag->base);
pid_t pid = waitpid(0,NULL,0);
printf("pid %d dead!!\n",pid);
// printf("str:%p,%s\n",&(strTag->str),strTag->str);
// free(strTag->str);
event_base_loopbreak(event_get_base(arg));
printf("parent dead!!\n");
// exit(-1);
}
void
rspamd_redis_finalize_learn (struct rspamd_task *task, gpointer runtime,
gpointer ctx)
{
struct redis_stat_runtime *rt = REDIS_RUNTIME (runtime);
redisAsyncContext *redis;
if (event_get_base (&rt->timeout_event)) {
event_del (&rt->timeout_event);
}
if (rt->redis) {
redis = rt->redis;
rt->redis = NULL;
redisAsyncFree (redis);
}
}
/* Called on connection termination */
static void
rspamd_redis_cache_fin (gpointer data)
{
struct rspamd_redis_cache_runtime *rt = data;
redisAsyncContext *redis;
rt->has_event = FALSE;
if (event_get_base (&rt->timeout_event)) {
event_del (&rt->timeout_event);
}
if (rt->redis) {
redis = rt->redis;
rt->redis = NULL;
/* This calls for all callbacks pending */
redisAsyncFree (redis);
}
}
static void
rspamd_redis_fin_learn (gpointer data)
{
struct redis_stat_runtime *rt = REDIS_RUNTIME (data);
redisAsyncContext *redis;
rt->has_event = FALSE;
/* Stop timeout */
if (event_get_base (&rt->timeout_event)) {
event_del (&rt->timeout_event);
}
if (rt->redis) {
redis = rt->redis;
rt->redis = NULL;
/* This calls for all callbacks pending */
redisAsyncFree (redis);
}
}
static void
fifo_read(evutil_socket_t fd, short event, void *arg)
{
char buf[255];
int len;
struct event *ev = arg;
#ifdef _WIN32
DWORD dwBytesRead;
#endif
fprintf(stderr, "fifo_read called with fd: %d, event: %d, arg: %p\n",
(int)fd, event, arg);
#ifdef _WIN32
len = ReadFile((HANDLE)fd, buf, sizeof(buf) - 1, &dwBytesRead, NULL);
/* Check for end of file. */
if (len && dwBytesRead == 0) {
fprintf(stderr, "End Of File");
event_del(ev);
return;
}
buf[dwBytesRead] = '\0';
#else
len = read(fd, buf, sizeof(buf) - 1);
if (len <= 0) {//读失败或者读结束时执行
if (len == -1)
perror("read");
else if (len == 0)
fprintf(stderr, "Connection closed\n");
event_del(ev);
event_base_loopbreak(event_get_base(ev));
return;
}
buf[len] = '\0';
#endif
fprintf(stdout, "Read: %s\n", buf);
}
static void sigint_cb(evutil_socket_t fd, short event, void *arg)
{
struct event *signal = (struct event *)arg;
printf("Terminating on SIGINT\n");
event_base_loopbreak(event_get_base(signal));
}
gboolean
rspamd_ssl_connect_fd (struct rspamd_ssl_connection *conn, gint fd,
const gchar *hostname, struct event *ev, struct timeval *tv,
rspamd_ssl_handler_t handler, rspamd_ssl_error_handler_t err_handler,
gpointer handler_data)
{
gint ret;
short what;
g_assert (conn != NULL);
if (conn->state != ssl_conn_reset) {
return FALSE;
}
conn->fd = fd;
conn->ev = ev;
conn->handler = handler;
conn->err_handler = err_handler;
conn->handler_data = handler_data;
if (SSL_set_fd (conn->ssl, fd) != 1) {
return FALSE;
}
if (hostname) {
conn->hostname = g_strdup (hostname);
#ifdef HAVE_SSL_TLSEXT_HOSTNAME
SSL_set_tlsext_host_name (conn->ssl, hostname);
#endif
}
conn->state = ssl_conn_init;
ret = SSL_connect (conn->ssl);
if (ret == 1) {
conn->state = ssl_conn_connected;
if (event_get_base (ev)) {
event_del (ev);
}
event_set (ev, fd, EV_WRITE, rspamd_ssl_event_handler, conn);
if (conn->ev_base) {
event_base_set (conn->ev_base, ev);
}
event_add (ev, tv);
}
else {
ret = SSL_get_error (conn->ssl, ret);
if (ret == SSL_ERROR_WANT_READ) {
what = EV_READ;
}
else if (ret == SSL_ERROR_WANT_WRITE) {
what = EV_WRITE;
}
else {
return FALSE;
}
if (event_get_base (ev)) {
event_del (ev);
}
event_set (ev, fd, what, rspamd_ssl_event_handler, conn);
event_base_set (conn->ev_base, ev);
event_add (ev, tv);
}
return TRUE;
}
gboolean
rspamd_redis_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
gint id, gpointer p)
{
struct redis_stat_runtime *rt = REDIS_RUNTIME (p);
struct upstream *up;
rspamd_inet_addr_t *addr;
struct timeval tv;
rspamd_fstring_t *query;
const gchar *redis_cmd;
rspamd_token_t *tok;
gint ret;
up = rspamd_upstream_get (rt->ctx->write_servers,
RSPAMD_UPSTREAM_MASTER_SLAVE,
NULL,
0);
if (up == NULL) {
msg_err_task ("no upstreams reachable");
return FALSE;
}
rt->selected = up;
addr = rspamd_upstream_addr (up);
g_assert (addr != NULL);
rt->redis = redisAsyncConnect (rspamd_inet_address_to_string (addr),
rspamd_inet_address_get_port (addr));
g_assert (rt->redis != NULL);
redisLibeventAttach (rt->redis, task->ev_base);
rspamd_redis_maybe_auth (rt->ctx, rt->redis);
/*
* Add the current key to the set of learned keys
*/
redisAsyncCommand (rt->redis, NULL, NULL, "SADD %s_keys %s",
rt->stcf->symbol, rt->redis_object_expanded);
if (rt->stcf->clcf->flags & RSPAMD_FLAG_CLASSIFIER_INTEGER) {
redis_cmd = "HINCRBY";
}
else {
redis_cmd = "HINCRBYFLOAT";
}
rt->id = id;
query = rspamd_redis_tokens_to_query (task, tokens,
redis_cmd, rt->redis_object_expanded, TRUE, id,
rt->stcf->clcf->flags & RSPAMD_FLAG_CLASSIFIER_INTEGER);
g_assert (query != NULL);
/*
* XXX:
* Dirty hack: we get a token and check if it's value is -1 or 1, so
* we could understand that we are learning or unlearning
*/
tok = g_ptr_array_index (task->tokens, 0);
if (tok->values[id] > 0) {
rspamd_printf_fstring (&query, ""
"*4\r\n"
"$7\r\n"
"HINCRBY\r\n"
"$%d\r\n"
"%s\r\n"
"$6\r\n"
"learns\r\n"
"$1\r\n"
"1\r\n",
(gint)strlen (rt->redis_object_expanded),
rt->redis_object_expanded);
}
else {
rspamd_printf_fstring (&query, ""
"*4\r\n"
"$7\r\n"
"HINCRBY\r\n"
"$%d\r\n"
"%s\r\n"
"$6\r\n"
"learns\r\n"
"$2\r\n"
"-1\r\n",
(gint)strlen (rt->redis_object_expanded),
rt->redis_object_expanded);
}
rspamd_mempool_add_destructor (task->task_pool,
(rspamd_mempool_destruct_t)rspamd_fstring_free, query);
ret = redisAsyncFormattedCommand (rt->redis, rspamd_redis_learned, rt,
query->str, query->len);
if (ret == REDIS_OK) {
rspamd_session_add_event (task->s, rspamd_redis_fin_learn, rt,
rspamd_redis_stat_quark ());
rt->has_event = TRUE;
/* Set timeout */
if (event_get_base (&rt->timeout_event)) {
event_del (&rt->timeout_event);
}
event_set (&rt->timeout_event, -1, EV_TIMEOUT, rspamd_redis_timeout, rt);
event_base_set (task->ev_base, &rt->timeout_event);
double_to_tv (rt->ctx->timeout, &tv);
event_add (&rt->timeout_event, &tv);
return TRUE;
}
else {
msg_err_task ("call to redis failed: %s", rt->redis->errstr);
}
return FALSE;
}
static void timerout1(evutil_socket_t fd, short events, void *arg)
{
event_base_loopbreak(event_get_base(arg));
kill(getppid(),SIGUSR1);
}
