1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*-
* Copyright 2016 Vsevolod Stakhov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RSPAMD_EVENTS_H
#define RSPAMD_EVENTS_H
#include "config.h"
#include "mem_pool.h"
struct rspamd_async_event;
struct rspamd_async_session;
struct rspamd_async_watcher;
typedef void (*event_finalizer_t)(gpointer ud);
typedef void (*event_watcher_t)(gpointer session_data, gpointer ud);
typedef gboolean (*session_finalizer_t)(gpointer user_data);
/**
* Make new async session
* @param pool pool to alloc memory from
* @param fin a callback called when no events are found in session
* @param restore a callback is called to restore processing of session
* @param cleanup a callback called when session is forcefully destroyed
* @param user_data abstract user data
* @return
*/
struct rspamd_async_session * rspamd_session_create (rspamd_mempool_t *pool,
session_finalizer_t fin, event_finalizer_t restore,
event_finalizer_t cleanup, gpointer user_data);
/**
* Insert new event to the session
* @param session session object
* @param fin finalizer callback
* @param user_data abstract user_data
* @param forced unused
*/
struct rspamd_async_event* rspamd_session_add_event (
struct rspamd_async_session *session,
event_finalizer_t fin, gpointer user_data, GQuark subsystem);
/**
* Remove normal event
* @param session session object
* @param fin final callback
* @param ud user data object
*/
void rspamd_session_remove_event (struct rspamd_async_session *session,
event_finalizer_t fin,
gpointer ud);
/**
* Must be called at the end of session, it calls fin functions for all non-forced callbacks
* @return true if the whole session was destroyed and false if there are forced events
*/
gboolean rspamd_session_destroy (struct rspamd_async_session *session);
/**
* Try to remove all events pending
*/
void rspamd_session_cleanup (struct rspamd_async_session *session);
/**
* Returns mempool associated with async session
* @param session
* @return
*/
rspamd_mempool_t * rspamd_session_mempool (struct rspamd_async_session *session);
/**
* Check session for events pending and call fin callback if no events are pending
* @param session session object
* @return TRUE if session has pending events
*/
gboolean rspamd_session_pending (struct rspamd_async_session *session);
/**
* Returns number of events pending
* @param session
* @return
*/
guint rspamd_session_events_pending (struct rspamd_async_session *session);
/**
* Start watching for events in the session, so the specified watcher will be added
* to all subsequent events until `rspamd_session_watch_stop` is called
* @param s session object
* @param cb watcher callback that is called when all events watched are destroyed
* @param ud opaque data for the callback
*/
void rspamd_session_watch_start (struct rspamd_async_session *s,
gint id,
event_watcher_t cb,
gpointer ud);
/**
* Stop watching mode, if no events are watched since the last `rspamd_session_watch_start`,
* then the watcher is silently ignored
* @param s session
* @return number of events watched
*/
guint rspamd_session_watch_stop (struct rspamd_async_session *s);
/**
* Create a fake event just for event watcher
* @param s
*/
void rspamd_session_watcher_push (struct rspamd_async_session *s);
/**
* Push callback to the watcher specified
*/
void rspamd_session_watcher_push_callback (struct rspamd_async_session *s,
struct rspamd_async_watcher *w,
event_watcher_t cb,
gpointer ud);
/**
* Increase refcount for a specific watcher
*/
void rspamd_session_watcher_push_specific (struct rspamd_async_session *s,
struct rspamd_async_watcher *w);
/**
* Remove a fake event from a watcher
* @param s
*/
void rspamd_session_watcher_pop (struct rspamd_async_session *s,
struct rspamd_async_watcher *w);
/**
* Returns the current watcher for events session
* @param s
* @return
*/
struct rspamd_async_watcher* rspamd_session_get_watcher (
struct rspamd_async_session *s);
#endif /* RSPAMD_EVENTS_H */
|
