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); }