Remove memory allocation in olsr_timer_add()
[oonf.git] / src / core / olsr_socket.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2004-2011, 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 "olsr_clock.h"
51 #include "olsr_logging.h"
52 #include "os_net.h"
53 #include "olsr_socket.h"
54 #include "olsr.h"
55
56 /* List of all active sockets in scheduler */
57 struct list_entity socket_head;
58
59 /* remember if initialized or not */
60 OLSR_SUBSYSTEM_STATE(_socket_state);
61
62 /**
63  * Initialize olsr socket scheduler
64  */
65 void
66 olsr_socket_init(void) {
67   if (olsr_subsystem_init(&_socket_state))
68     return;
69
70   list_init_head(&socket_head);
71 }
72
73 /**
74  * Cleanup olsr socket scheduler.
75  * This will close and free all sockets.
76  */
77 void
78 olsr_socket_cleanup(void)
79 {
80   struct olsr_socket_entry *entry, *iterator;
81
82   if (olsr_subsystem_cleanup(&_socket_state))
83     return;
84
85   OLSR_FOR_ALL_SOCKETS(entry, iterator) {
86     list_remove(&entry->node);
87     os_close(entry->fd);
88   }
89 }
90
91 /**
92  * Add a socket handler to the scheduler
93  *
94  * @param handler pointer to initialized socket entry
95  * @return -1 if an error happened, 0 otherwise
96  */
97 void
98 olsr_socket_add(struct olsr_socket_entry *entry)
99 {
100   assert (entry->fd >= 0);
101   assert (entry->process);
102
103   OLSR_DEBUG(LOG_SOCKET, "Adding socket entry %d to scheduler\n", entry->fd);
104
105   list_add_before(&socket_head, &entry->node);
106 }
107
108 /**
109  * Remove a socket from the socket scheduler
110  * @param entry pointer to socket entry
111  */
112 void
113 olsr_socket_remove(struct olsr_socket_entry *entry)
114 {
115   OLSR_DEBUG(LOG_SOCKET, "Removing socket entry %d\n", entry->fd);
116
117   list_remove(&entry->node);
118 }
119
120 /**
121  * Handle all incoming socket events until a certain time
122  * @param until_time timestamp when the function should return
123  * @return -1 if an error happened, 0 otherwise
124  */
125 int
126 olsr_socket_handle(uint32_t until_time)
127 {
128   struct olsr_socket_entry *entry, *iterator;
129   struct timeval tvp;
130   int32_t remaining;
131   int n = 0;
132   bool fd_read;
133   bool fd_write;
134
135   /* Update time since this is much used by the parsing functions */
136   if (olsr_clock_update()) {
137     return -1;
138   }
139
140   remaining = olsr_clock_getRelative(until_time);
141   if (remaining <= 0) {
142     /* we are already over the interval */
143     if (list_is_empty(&socket_head)) {
144       /* If there are no registered sockets we do not call select(2) */
145       return 0;
146     }
147     tvp.tv_sec = 0;
148     tvp.tv_usec = 0;
149   } else {
150     /* we need an absolute time - milliseconds */
151     tvp.tv_sec = remaining / MSEC_PER_SEC;
152     tvp.tv_usec = (remaining % MSEC_PER_SEC) * USEC_PER_MSEC;
153   }
154
155   /* do at least one select */
156   for (;;) {
157     fd_set ibits, obits;
158     int hfd = 0;
159
160     fd_read = false;
161     fd_write = false;
162
163     FD_ZERO(&ibits);
164     FD_ZERO(&obits);
165
166     /* Adding file-descriptors to FD set */
167     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
168       if (entry->process == NULL) {
169         continue;
170       }
171
172       if (entry->event_read) {
173         fd_read = true;
174         FD_SET((unsigned int)entry->fd, &ibits);        /* And we cast here since we get a warning on Win32 */
175       }
176       if (entry->event_write) {
177         fd_write = true;
178         FD_SET((unsigned int)entry->fd, &obits);        /* And we cast here since we get a warning on Win32 */
179       }
180       if ((entry->event_read || entry->event_write) != 0 && entry->fd >= hfd) {
181         hfd = entry->fd + 1;
182       }
183     }
184
185     if (hfd == 0 && (long)remaining <= 0) {
186       /* we are over the interval and we have no fd's. Skip the select() etc. */
187       return 0;
188     }
189
190     do {
191       n = os_select(hfd,
192           fd_read ? &ibits : NULL,
193           fd_write ? &obits : NULL,
194           NULL, &tvp);
195       if (!olsr_is_running()) {
196         return 0;
197       }
198     } while (n == -1 && errno == EINTR);
199
200     if (n == 0) {               /* timeout! */
201       break;
202     }
203     if (n < 0) {              /* Did something go wrong? */
204       OLSR_WARN(LOG_SOCKET, "select error: %s (%d)", strerror(errno), errno);
205       break;
206     }
207
208     /* Update time since this is much used by the parsing functions */
209     if (olsr_clock_update()) {
210       n = -1;
211       break;
212     }
213     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
214       if (entry->process == NULL) {
215         continue;
216       }
217
218       fd_read = FD_ISSET(entry->fd, &ibits) != 0;
219       fd_write = FD_ISSET(entry->fd, &obits) != 0;
220       if (fd_read || fd_write) {
221         entry->process(entry->fd, entry->data, fd_read, fd_write);
222       }
223     }
224
225     /* calculate the next timeout */
226     remaining = olsr_clock_getRelative(until_time);
227     if (remaining <= 0) {
228       /* we are already over the interval */
229       break;
230     }
231     /* we need an absolute time - milliseconds */
232     tvp.tv_sec = remaining / MSEC_PER_SEC;
233     tvp.tv_usec = (remaining % MSEC_PER_SEC) * USEC_PER_MSEC;
234   }
235
236   if (n<0)
237     return -1;
238   return 0;
239 }