06c4b4109f094e3f8daaa9778f1a022f43541989
[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   _stop_scheduler = true;
132 }
133
134 /**
135  * Handle all incoming socket events until a certain time
136  * @param stop_time timestamp when the handler should stop,
137  *   0 if it should keep running
138  * @return -1 if an error happened, 0 otherwise
139  */
140 int
141 olsr_socket_handle(uint64_t stop_time)
142 {
143   struct olsr_socket_entry *entry, *iterator;
144   uint64_t next_event;
145   struct timeval tv, *tv_ptr;
146   int n = 0;
147   bool fd_read;
148   bool fd_write;
149
150   if (stop_time == 0) {
151     stop_time = ~0ull;
152   }
153
154   _stop_scheduler = false;
155
156   while (true) {
157     fd_set ibits, obits;
158     int hfd = 0;
159
160     /* Update time since this is much used by the parsing functions */
161     if (olsr_clock_update()) {
162       return -1;
163     }
164
165     if (olsr_clock_getNow() >= stop_time) {
166       return 0;
167     }
168
169     if (olsr_timer_getNextEvent() <= olsr_clock_getNow()) {
170       olsr_timer_walk();
171     }
172
173     if (_stop_scheduler) {
174       return 0;
175     }
176
177     /* no event left for now, prepare for select () */
178     fd_read = false;
179     fd_write = false;
180
181     FD_ZERO(&ibits);
182     FD_ZERO(&obits);
183
184     /* Adding file-descriptors to FD set */
185     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
186       if (entry->process == NULL) {
187         continue;
188       }
189
190       if (entry->event_read) {
191         fd_read = true;
192         FD_SET((unsigned int)entry->fd, &ibits);        /* And we cast here since we get a warning on Win32 */
193       }
194       if (entry->event_write) {
195         fd_write = true;
196         FD_SET((unsigned int)entry->fd, &obits);        /* And we cast here since we get a warning on Win32 */
197       }
198       if ((entry->event_read || entry->event_write) != 0 && entry->fd >= hfd) {
199         hfd = entry->fd + 1;
200       }
201     }
202
203     next_event = olsr_timer_getNextEvent();
204     if (next_event > stop_time) {
205       next_event = stop_time;
206     }
207
208     if (next_event == ~0ull) {
209       /* no events waiting */
210       tv_ptr = NULL;
211     }
212     else {
213       /* convert time interval until event triggers */
214       next_event = olsr_clock_get_relative(next_event);
215
216       tv_ptr = &tv;
217       tv.tv_sec = (time_t)(next_event / 1000ull);
218       tv.tv_usec = (int)(next_event % 1000) * 1000;
219     }
220
221     do {
222       if (_stop_scheduler) {
223         return 0;
224       }
225       n = os_select(hfd,
226           fd_read ? &ibits : NULL,
227           fd_write ? &obits : NULL,
228           NULL, tv_ptr);
229     } while (n == -1 && errno == EINTR);
230
231     if (n == 0) {               /* timeout! */
232       break;
233     }
234     if (n < 0) {              /* Did something go wrong? */
235       OLSR_WARN(LOG_SOCKET, "select error: %s (%d)", strerror(errno), errno);
236       return -1;
237     }
238
239     /* Update time since this is much used by the parsing functions */
240     if (olsr_clock_update()) {
241       return -1;
242     }
243     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
244       if (entry->process == NULL) {
245         continue;
246       }
247
248       fd_read = FD_ISSET(entry->fd, &ibits) != 0;
249       fd_write = FD_ISSET(entry->fd, &obits) != 0;
250       if (fd_read || fd_write) {
251         entry->process(entry->fd, entry->data, fd_read, fd_write);
252       }
253     }
254   }
255   return 0;
256 }