More work on API dependencies
[oonf.git] / src-api / core / olsr_socket.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2004-2013, the olsr.org team - see HISTORY file
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright
14  *   notice, this list of conditions and the following disclaimer in
15  *   the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of olsr.org, olsrd nor the names of its
18  *   contributors may be used to endorse or promote products derived
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Visit http://www.olsr.org for more information.
35  *
36  * If you find this software useful feel free to make a donation
37  * to the project. For more information see the website or contact
38  * the copyright holders.
39  *
40  */
41
42 #include <unistd.h>
43 #include <assert.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <errno.h>
47
48 #include "common/avl.h"
49 #include "common/avl_comp.h"
50 #include "core/olsr_clock.h"
51 #include "core/olsr_logging.h"
52 #include "core/os_net.h"
53 #include "core/olsr_socket.h"
54 #include "core/olsr_timer.h"
55 #include "core/olsr_subsystem.h"
56
57 /* prototypes */
58 static int _init(void);
59 static void _cleanup(void);
60
61 /* List of all active sockets in scheduler */
62 struct list_entity socket_head;
63
64 static bool _stop_scheduler;
65
66 /* subsystem definition */
67 struct oonf_subsystem oonf_socket_subsystem = {
68   .init = _init,
69   .cleanup = _cleanup,
70 };
71
72 /**
73  * Initialize olsr socket scheduler
74  * @return always returns 0
75  */
76 static int
77 _init(void) {
78   list_init_head(&socket_head);
79   return 0;
80 }
81
82 /**
83  * Cleanup olsr socket scheduler.
84  * This will close and free all sockets.
85  */
86 static void
87 _cleanup(void)
88 {
89   struct olsr_socket_entry *entry, *iterator;
90
91   OLSR_FOR_ALL_SOCKETS(entry, iterator) {
92     list_remove(&entry->node);
93     os_close(entry->fd);
94   }
95 }
96
97 /**
98  * Add a socket handler to the scheduler
99  *
100  * @param entry pointer to initialized socket entry
101  * @return -1 if an error happened, 0 otherwise
102  */
103 void
104 olsr_socket_add(struct olsr_socket_entry *entry)
105 {
106   assert (entry->fd >= 0);
107   assert (entry->process);
108
109   OLSR_DEBUG(LOG_SOCKET, "Adding socket entry %d to scheduler\n", entry->fd);
110
111   list_add_before(&socket_head, &entry->node);
112 }
113
114 /**
115  * Remove a socket from the socket scheduler
116  * @param entry pointer to socket entry
117  */
118 void
119 olsr_socket_remove(struct olsr_socket_entry *entry)
120 {
121   OLSR_DEBUG(LOG_SOCKET, "Removing socket entry %d\n", entry->fd);
122
123   list_remove(&entry->node);
124 }
125
126 /**
127  * Prevent the scheduler from waiting until timeout.
128  */
129 void
130 olsr_socket_stop_scheduler(void) {
131   // TODO: invert, lets call olsr_cfg function instead of setting the variable here
132   _stop_scheduler = true;
133 }
134
135 /**
136  * Handle all incoming socket events until a certain time
137  * @param stop_time timestamp when the handler should stop,
138  *   0 if it should keep running
139  * @return -1 if an error happened, 0 otherwise
140  */
141 int
142 olsr_socket_handle(uint64_t stop_time)
143 {
144   struct olsr_socket_entry *entry, *iterator;
145   uint64_t next_event;
146   struct timeval tv, *tv_ptr;
147   int n = 0;
148   bool fd_read;
149   bool fd_write;
150
151   if (stop_time == 0) {
152     stop_time = ~0ull;
153   }
154
155   _stop_scheduler = false;
156
157   while (true) {
158     fd_set ibits, obits;
159     int hfd = 0;
160
161     /* Update time since this is much used by the parsing functions */
162     if (olsr_clock_update()) {
163       return -1;
164     }
165
166     if (olsr_clock_getNow() >= stop_time) {
167       return 0;
168     }
169
170     if (olsr_timer_getNextEvent() <= olsr_clock_getNow()) {
171       olsr_timer_walk();
172     }
173
174     if (_stop_scheduler) {
175       return 0;
176     }
177
178     /* no event left for now, prepare for select () */
179     fd_read = false;
180     fd_write = false;
181
182     FD_ZERO(&ibits);
183     FD_ZERO(&obits);
184
185     /* Adding file-descriptors to FD set */
186     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
187       if (entry->process == NULL) {
188         continue;
189       }
190
191       if (entry->event_read) {
192         fd_read = true;
193         FD_SET((unsigned int)entry->fd, &ibits);        /* And we cast here since we get a warning on Win32 */
194       }
195       if (entry->event_write) {
196         fd_write = true;
197         FD_SET((unsigned int)entry->fd, &obits);        /* And we cast here since we get a warning on Win32 */
198       }
199       if ((entry->event_read || entry->event_write) != 0 && entry->fd >= hfd) {
200         hfd = entry->fd + 1;
201       }
202     }
203
204     next_event = olsr_timer_getNextEvent();
205     if (next_event > stop_time) {
206       next_event = stop_time;
207     }
208
209     if (next_event == ~0ull) {
210       /* no events waiting */
211       tv_ptr = NULL;
212     }
213     else {
214       /* convert time interval until event triggers */
215       next_event = olsr_clock_get_relative(next_event);
216
217       tv_ptr = &tv;
218       tv.tv_sec = (time_t)(next_event / 1000ull);
219       tv.tv_usec = (int)(next_event % 1000) * 1000;
220     }
221
222     do {
223       if (_stop_scheduler) {
224         return 0;
225       }
226       n = os_select(hfd,
227           fd_read ? &ibits : NULL,
228           fd_write ? &obits : NULL,
229           NULL, tv_ptr);
230     } while (n == -1 && errno == EINTR);
231
232     if (n == 0) {               /* timeout! */
233       break;
234     }
235     if (n < 0) {              /* Did something go wrong? */
236       OLSR_WARN(LOG_SOCKET, "select error: %s (%d)", strerror(errno), errno);
237       return -1;
238     }
239
240     /* Update time since this is much used by the parsing functions */
241     if (olsr_clock_update()) {
242       return -1;
243     }
244     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
245       if (entry->process == NULL) {
246         continue;
247       }
248
249       fd_read = FD_ISSET(entry->fd, &ibits) != 0;
250       fd_write = FD_ISSET(entry->fd, &obits) != 0;
251       if (fd_read || fd_write) {
252         entry->process(entry->fd, entry->data, fd_read, fd_write);
253       }
254     }
255   }
256   return 0;
257 }