PUD: determine the best gateway on a regular schedule
[olsrd.git] / lib / pud / src / timers.c
1 #include "timers.h"
2
3 /* Plugin includes */
4 #include "pud.h"
5
6 /* OLSRD includes */
7 #include "olsr_cookie.h"
8 #include "scheduler.h"
9
10 /* System includes */
11 #include <stddef.h>
12 #include <stdbool.h>
13
14 /*
15  * OLSR Tx Timer
16  */
17
18 /** The timer cookie, used to trace back the originator in debug */
19 static struct olsr_cookie_info *pud_olsr_tx_timer_cookie = NULL;
20
21 /** The timer */
22 static struct timer_entry * pud_olsr_tx_timer = NULL;
23
24 /**
25  Start the OLSR tx timer. Does nothing when the timer is already running.
26
27  @param interval
28  The interval in seconds
29  @param cb_func
30  The callback function to call when the timer expires
31
32  @return
33  - false on failure
34  - true otherwise
35  */
36 static int startOlsrTxTimer(unsigned long long interval, timer_cb_func cb_func) {
37         if (pud_olsr_tx_timer == NULL) {
38                 pud_olsr_tx_timer = olsr_start_timer(interval * MSEC_PER_SEC, 0,
39                                 OLSR_TIMER_PERIODIC, cb_func, NULL,
40                                 pud_olsr_tx_timer_cookie);
41                 if (pud_olsr_tx_timer == NULL) {
42                         return false;
43                 }
44         }
45
46         return true;
47 }
48
49 /**
50  Stop the OLSR tx timer
51  */
52 static void stopOlsrTxTimer(void) {
53         if (pud_olsr_tx_timer != NULL) {
54                 olsr_stop_timer(pud_olsr_tx_timer);
55                 pud_olsr_tx_timer = NULL;
56         }
57 }
58
59 /**
60  Restart the OLSR tx timer
61
62  @param interval
63  The interval in seconds
64  @param cb_func
65  The callback function to call when the timer expires
66
67  @return
68  - false on failure
69  - true otherwise
70  */
71 int restartOlsrTxTimer(unsigned long long interval, timer_cb_func cb_func) {
72         stopOlsrTxTimer();
73         return startOlsrTxTimer(interval, cb_func);
74 }
75
76 /**
77  Initialise the OLSR tx timer.
78
79  @return
80  - false on failure
81  - true otherwise
82  */
83 int initOlsrTxTimer(void) {
84         if (pud_olsr_tx_timer_cookie == NULL) {
85                 pud_olsr_tx_timer_cookie = olsr_alloc_cookie(
86                                 PUD_PLUGIN_ABBR ": OLSR tx timer", OLSR_COOKIE_TYPE_TIMER);
87                 if (pud_olsr_tx_timer_cookie == NULL) {
88                         return false;
89                 }
90         }
91         return true;
92 }
93
94 /**
95  Destroy the OLSR tx timer.
96  */
97 void destroyOlsrTxTimer(void) {
98         stopOlsrTxTimer();
99         if (pud_olsr_tx_timer_cookie != NULL) {
100                 olsr_free_cookie(pud_olsr_tx_timer_cookie);
101                 pud_olsr_tx_timer_cookie = NULL;
102         }
103 }
104
105 /*
106  * Uplink Tx Timer
107  */
108
109 /** The timer cookie, used to trace back the originator in debug */
110 static struct olsr_cookie_info *pud_uplink_tx_timer_cookie = NULL;
111
112 /** The timer */
113 static struct timer_entry * pud_uplink_tx_timer = NULL;
114
115 /**
116  Start the uplink tx timer. Does nothing when the timer is already running.
117
118  @param interval
119  The interval in seconds
120  @param cb_func
121  The callback function to call when the timer expires
122
123  @return
124  - false on failure
125  - true otherwise
126  */
127 static int startUplinkTxTimer(unsigned long long interval, timer_cb_func cb_func) {
128         if (pud_uplink_tx_timer == NULL) {
129                 pud_uplink_tx_timer = olsr_start_timer(interval * MSEC_PER_SEC, 0,
130                                 OLSR_TIMER_PERIODIC, cb_func, NULL,
131                                 pud_uplink_tx_timer_cookie);
132                 if (pud_uplink_tx_timer == NULL) {
133                         return false;
134                 }
135         }
136
137         return true;
138 }
139
140 /**
141  Stop the uplink tx timer
142  */
143 static void stopUplinkTxTimer(void) {
144         if (pud_uplink_tx_timer != NULL) {
145                 olsr_stop_timer(pud_uplink_tx_timer);
146                 pud_uplink_tx_timer = NULL;
147         }
148 }
149
150 /**
151  Restart the uplink tx timer
152
153  @param interval
154  The interval in seconds
155  @param cb_func
156  The callback function to call when the timer expires
157
158  @return
159  - false on failure
160  - true otherwise
161  */
162 int restartUplinkTxTimer(unsigned long long interval, timer_cb_func cb_func) {
163         stopUplinkTxTimer();
164         return startUplinkTxTimer(interval, cb_func);
165 }
166
167 /**
168  Initialise the uplink tx timer.
169
170  @return
171  - false on failure
172  - true otherwise
173  */
174 int initUplinkTxTimer(void) {
175         if (pud_uplink_tx_timer_cookie == NULL) {
176                 pud_uplink_tx_timer_cookie = olsr_alloc_cookie(
177                                 PUD_PLUGIN_ABBR ": uplink tx timer", OLSR_COOKIE_TYPE_TIMER);
178                 if (pud_uplink_tx_timer_cookie == NULL) {
179                         return false;
180                 }
181         }
182         return true;
183 }
184
185 /**
186  Destroy the uplink tx timer.
187  */
188 void destroyUplinkTxTimer(void) {
189         stopUplinkTxTimer();
190         if (pud_uplink_tx_timer_cookie != NULL) {
191                 olsr_free_cookie(pud_uplink_tx_timer_cookie);
192                 pud_uplink_tx_timer_cookie = NULL;
193         }
194 }
195
196 /*
197  * Best Gateway Timer
198  */
199
200 /** The timer cookie, used to trace back the originator in debug */
201 static struct olsr_cookie_info *pud_gateway_timer_cookie = NULL;
202
203 /** The timer */
204 static struct timer_entry * pud_gateway_timer = NULL;
205
206 /**
207  Start the gateway timer. Does nothing when the timer is already running.
208
209  @param interval
210  The interval in seconds
211  @param cb_func
212  The callback function to call when the timer expires
213
214  @return
215  - false on failure
216  - true otherwise
217  */
218 static int startGatewayTimer(unsigned long long interval, timer_cb_func cb_func) {
219         if (pud_gateway_timer == NULL) {
220                 pud_gateway_timer = olsr_start_timer(interval * MSEC_PER_SEC, 0,
221                                 OLSR_TIMER_PERIODIC, cb_func, NULL,
222                                 pud_gateway_timer_cookie);
223                 if (pud_gateway_timer == NULL) {
224                         return false;
225                 }
226         }
227
228         return true;
229 }
230
231 /**
232  Stop the gateway timer
233  */
234 static void stopGatewayTimer(void) {
235         if (pud_gateway_timer != NULL) {
236                 olsr_stop_timer(pud_gateway_timer);
237                 pud_gateway_timer = NULL;
238         }
239 }
240
241 /**
242  Restart the gateway timer
243
244  @param interval
245  The interval in seconds
246  @param cb_func
247  The callback function to call when the timer expires
248
249  @return
250  - false on failure
251  - true otherwise
252  */
253 int restartGatewayTimer(unsigned long long interval, timer_cb_func cb_func) {
254         stopGatewayTimer();
255         return startGatewayTimer(interval, cb_func);
256 }
257
258 /**
259  Initialise the gateway timer.
260
261  @return
262  - false on failure
263  - true otherwise
264  */
265 int initGatewayTimer(void) {
266         if (pud_gateway_timer_cookie == NULL) {
267                 pud_gateway_timer_cookie = olsr_alloc_cookie(
268                                 PUD_PLUGIN_ABBR ": gateway timer", OLSR_COOKIE_TYPE_TIMER);
269                 if (pud_gateway_timer_cookie == NULL) {
270                         return false;
271                 }
272         }
273         return true;
274 }
275
276 /**
277  Destroy the gateway timer.
278  */
279 void destroyGatewayTimer(void) {
280         stopGatewayTimer();
281         if (pud_gateway_timer_cookie != NULL) {
282                 olsr_free_cookie(pud_gateway_timer_cookie);
283                 pud_gateway_timer_cookie = NULL;
284         }
285 }