gateway: simplify stopping the cleanup timer
[olsrd.git] / lib / tas / src / os_unix.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon (olsrd)
4  *
5  * Copyright (c) 2004, Thomas Lopatic (thomas@olsr.org)
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * * Redistributions of source code must retain the above copyright
13  *   notice, this list of conditions and the following disclaimer.
14  * * Redistributions in binary form must reproduce the above copyright
15  *   notice, this list of conditions and the following disclaimer in
16  *   the documentation and/or other materials provided with the
17  *   distribution.
18  * * Neither the name of olsr.org, olsrd nor the names of its
19  *   contributors may be used to endorse or promote products derived
20  *   from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33  * POSSIBILITY OF SUCH DAMAGE.
34  *
35  * Visit http://www.olsr.org for more information.
36  *
37  * If you find this software useful feel free to make a donation
38  * to the project. For more information see the website or contact
39  * the copyright holders.
40  *
41  */
42
43 #ifdef __linux__
44
45 #include "link.h"
46 #include "plugin.h"
47 #include "lib.h"
48 #include "os_unix.h"
49 #include "http.h"
50 #include "glua.h"
51 #include "glua_ext.h"
52 #include "defs.h" /* ARM_NOWARN_ALIGN */
53
54 #include <sys/types.h>
55 #include <sys/socket.h>
56 #include <arpa/inet.h>
57 #include <unistd.h>
58 #include <stdio.h>
59 #include <errno.h>
60 #include <string.h>
61 #include <fcntl.h>
62 #include <stdlib.h>
63 #include <sys/select.h>
64 #include <sys/stat.h>
65 #include <sys/time.h>
66 #include <time.h>
67
68 static int mainSocket;
69
70 void
71 getRandomBytes(unsigned char *buff, int len)
72 {
73   int file;
74   int readLen;
75
76   memset(buff, 0, len);
77
78   file = open("/dev/random", O_RDONLY);
79
80   if (file < 0) {
81     fprintf(stderr, "warning: cannot open /dev/random\n");
82     return;
83   }
84
85   while (len > 0) {
86     readLen = read(file, buff, len);
87
88     if (readLen < 0) {
89       fprintf(stderr, "warning: cannot read from /dev/random\n");
90       close(file);
91       return;
92     }
93
94     buff += readLen;
95     len -= readLen;
96   }
97
98   close(file);
99 }
100
101 int
102 addrLen(int family)
103 {
104   return (family == AF_INET) ? sizeof(struct in_addr) : sizeof(struct in6_addr);
105 }
106
107 void
108 os_now(struct timeStamp *timeStamp)
109 {
110   timeStamp->time = time(NULL);
111 }
112
113 int
114 timedOut(struct timeStamp *timeStamp, int sec)
115 {
116   time_t now;
117
118   time(&now);
119
120   if ((time_t) (timeStamp->time + sec) > now)
121     return -1;
122
123   return 0;
124 }
125
126 unsigned int
127 getMicro(void)
128 {
129   struct timeval timeVal;
130   static struct timeval timeValPrev;
131   static int firstTime = 1;
132
133   gettimeofday(&timeVal, NULL);
134
135   if (firstTime == 0 && timeValPrev.tv_sec == timeVal.tv_sec && timeValPrev.tv_usec >= timeVal.tv_usec)
136     return timeValPrev.tv_sec * 1000000 + timeValPrev.tv_usec;
137
138   firstTime = 0;
139
140   timeValPrev.tv_sec = timeVal.tv_sec;
141   timeValPrev.tv_usec = timeVal.tv_usec;
142
143   return timeVal.tv_sec * 1000000 + timeVal.tv_usec;
144 }
145
146 void *
147 allocMem(int len)
148 {
149   void *res;
150
151   res = malloc(len);
152
153   if (res == NULL) {
154     fprintf(stderr, "cannot allocate %d bytes\n", len);
155     exit(0);
156   }
157
158   memset(res, 0, len);
159
160   return res;
161 }
162
163 void
164 freeMem(void *mem)
165 {
166   free(mem);
167 }
168
169 int
170 writeFileOs(const struct fileId *fileId, const unsigned char *data, int len)
171 {
172   int writeLen;
173
174   if (len == 0)
175     return 0;
176
177   do
178     writeLen = write(fileId->fileDesc, data, len);
179   while (writeLen < 0 && errno == EINTR);
180
181   if (writeLen < 0) {
182     if (errno == EAGAIN)
183       return 0;
184
185     error("cannot write to file descriptor: %s\n", strerror(errno));
186     return -1;
187   }
188
189   return writeLen;
190 }
191
192 int
193 readFileOs(const struct fileId *fileId, unsigned char *data, int len)
194 {
195   int readLen;
196
197   if (len == 0)
198     return 0;
199
200   do
201     readLen = read(fileId->fileDesc, data, len);
202   while (readLen < 0 && errno == EINTR);
203
204   if (readLen < 0) {
205     if (errno == EAGAIN)
206       return 0;
207
208     error("cannot read from file descriptor: %s\n", strerror(errno));
209     return -1;
210   }
211
212   if (readLen == 0)
213     return -1;
214
215   return readLen;
216 }
217
218 int
219 checkAbsPath(const char *path)
220 {
221   if (path[0] != '/')
222     return -1;
223
224   return 0;
225 }
226
227 char *
228 fullPath(const char *dir, const char *path)
229 {
230   int dirLen = strlen(dir);
231   int pathLen = strlen(path);
232   char *buff = allocMem(dirLen + pathLen + 2);
233
234   memcpy(buff, dir, dirLen);
235
236   if (dirLen == 0 || buff[dirLen - 1] == '/')
237     dirLen--;
238
239   else
240     buff[dirLen] = '/';
241
242   memcpy(buff + dirLen + 1, path, pathLen + 1);
243
244   return buff;
245 }
246
247 void
248 setExtension(char *res, const char *path, const char *ext)
249 {
250   int i;
251   int len = strlen(path);
252
253   for (i = len - 1; i >= 0 && path[i] != '.' && path[i] != '/'; i--);
254
255   if (path[i] == '.')
256     len = i;
257
258   memcpy(res, path, len);
259   memcpy(res + len, ext, strlen(ext) + 1);
260 }
261
262 int
263 isDirectory(const char *rootDir, const char *path)
264 {
265   char *full = fullPath(rootDir, path);
266   struct stat statBuff;
267   int res;
268
269   res = stat(full, &statBuff);
270
271   freeMem(full);
272
273   if (res < 0)
274     return -1;
275
276   return S_ISDIR(statBuff.st_mode);
277 }
278
279 int
280 openFile(struct fileId *fileId, const char *rootDir, const char *path)
281 {
282   int fileDesc;
283   char *full = fullPath(rootDir, path);
284
285   fileDesc = open(full, O_RDONLY | O_NONBLOCK);
286
287   if (fileDesc < 0) {
288     error("cannot open file %s: %s\n", full, strerror(errno));
289     freeMem(full);
290     return -1;
291   }
292
293   fileId->fileDesc = fileDesc;
294
295   freeMem(full);
296   return 0;
297 }
298
299 void
300 closeFile(const struct fileId *fileId)
301 {
302   close(fileId->fileDesc);
303 }
304
305 int
306 fileIsNewer(const char *fileName1, const char *fileName2)
307 {
308   struct stat stat1, stat2;
309
310   if (stat(fileName1, &stat1) < 0) {
311     error("cannot stat %s: %s\n", fileName1, strerror(errno));
312     return -1;
313   }
314
315   if (stat(fileName2, &stat2) < 0) {
316     if (errno != ENOENT)
317       error("cannot stat %s: %s\n", fileName2, strerror(errno));
318
319     return -1;
320   }
321
322   return stat1.st_mtime > stat2.st_mtime;
323 }
324
325 int
326 createAllDirs(char *path)
327 {
328   int i;
329   int fail;
330
331   for (i = 0; path[i] != 0; i++) {
332     if (path[i] == '/' && i > 0) {
333       path[i] = 0;
334
335       fail = (mkdir(path, 0755) < 0 && errno != EEXIST);
336
337       path[i] = '/';
338
339       if (fail)
340         return -1;
341     }
342   }
343
344   return 0;
345 }
346
347 int
348 parseIpAddr(struct ipAddr *addr, const char *addrStr)
349 {
350   memset(addr, 0, sizeof(struct ipAddr));
351
352   if (inet_pton(AF_INET, addrStr, &addr->addr.v4) > 0) {
353     addr->domain = PF_INET;
354     return 0;
355   }
356
357   if (inet_pton(AF_INET6, addrStr, &addr->addr.v6) > 0) {
358     addr->domain = PF_INET6;
359     return 0;
360   }
361
362   fprintf(stderr, "cannot parse IP address\n");
363   return -1;
364 }
365
366 char *
367 ipAddrToString(struct ipAddr *addr)
368 {
369   static char buff[8][40];
370   static int i = 0;
371   char *res;
372
373   res = buff[i];
374
375   if (addr->domain == PF_INET)
376     inet_ntop(AF_INET, &addr->addr.v4, res, 40);
377
378   else
379     inet_ntop(AF_INET6, &addr->addr.v6, res, 40);
380
381   i = (i + 1) & 7;
382
383   return res;
384 }
385
386 char *
387 rawIpAddrToString(void *rawAddr, int len)
388 {
389   struct ipAddr addr;
390
391   if (len == 4) {
392     memcpy(&addr.addr.v4, rawAddr, 4);
393     addr.domain = PF_INET;
394   }
395
396   else {
397     memcpy(&addr.addr.v6, rawAddr, 16);
398     addr.domain = PF_INET6;
399   }
400
401   return ipAddrToString(&addr);
402 }
403
404 static int
405 createSockAddr(struct sockaddr_storage *sockAddr, const struct ipAddr *addr, int port)
406 {
407   memset(sockAddr, 0, sizeof(struct sockaddr_storage));
408
409   if (addr->domain == PF_INET) {
410     struct sockaddr_in sin;
411     memset(&sin, 0, sizeof(sin));
412
413     sin.sin_family = AF_INET;
414     sin.sin_port = htons((short)port);
415     sin.sin_addr.s_addr = addr->addr.v4.s_addr;
416
417     memcpy(sockAddr, &sin, sizeof(sin));
418     return 0;
419   }
420
421   if (addr->domain == PF_INET6) {
422     struct sockaddr_in6 sin6;
423     memset(&sin6, 0, sizeof(sin6));
424
425     sin6.sin6_family = AF_INET6;
426     sin6.sin6_port = htons((short)port);
427     sin6.sin6_addr = addr->addr.v6;
428     memcpy(sockAddr, &sin6, sizeof(sin6));
429
430     return 0;
431   }
432
433   fprintf(stderr, "invalid protocol family: %d\n", addr->domain);
434   return -1;
435 }
436
437 static int
438 addrFromSockAddr(struct ipAddr *addr, const union olsr_sockaddr *sockAddr)
439 {
440   memset(addr, 0, sizeof(struct ipAddr));
441
442   if (sockAddr->in.sa_family == AF_INET) {
443     addr->domain = PF_INET;
444     addr->addr.v4.s_addr = sockAddr->in4.sin_addr.s_addr;
445     return 0;
446   }
447
448   if (sockAddr->in.sa_family == AF_INET6) {
449     addr->domain = PF_INET6;
450     memcpy(&addr->addr.v6, &sockAddr->in6.sin6_addr, sizeof(struct in6_addr));
451     return 0;
452   }
453
454   fprintf(stderr, "invalid address family: %d\n", sockAddr->in.sa_family);
455   return -1;
456 }
457
458 int
459 createMainSocket(const struct ipAddr *addr, int port)
460 {
461   struct sockaddr_storage sockAddr;
462   static int truePara = 1;
463   int flags;
464
465   if (createSockAddr(&sockAddr, addr, port) < 0) {
466     fprintf(stderr, "cannot create socket address\n");
467     return -1;
468   }
469
470   mainSocket = socket(addr->domain, SOCK_STREAM, IPPROTO_TCP);
471
472   if (mainSocket < 0) {
473     error("cannot create main socket: %s\n", strerror(errno));
474     return -1;
475   }
476
477   if (setsockopt(mainSocket, SOL_SOCKET, SO_REUSEADDR, &truePara, sizeof(truePara)) < 0) {
478     error("cannot set SO_REUSEADDR socket option: %s\n", strerror(errno));
479     close(mainSocket);
480     return -1;
481   }
482
483   flags = fcntl(mainSocket, F_GETFL);
484
485   if (flags < 0) {
486     error("cannot get flags : %s\n", strerror(errno));
487     close(mainSocket);
488     return -1;
489   }
490
491   if (fcntl(mainSocket, F_SETFL, flags | O_NONBLOCK) < 0) {
492     error("cannot set flags: %s\n", strerror(errno));
493     close(mainSocket);
494     return -1;
495   }
496
497   if (bind(mainSocket, (struct sockaddr *)&sockAddr, sizeof(struct sockaddr)) < 0) {
498     error("cannot bind main socket: %s\n", strerror(errno));
499     close(mainSocket);
500     return -1;
501   }
502
503   if (listen(mainSocket, 10) < 0) {
504     error("cannot listen on main socket: %s\n", strerror(errno));
505     close(mainSocket);
506     return -1;
507   }
508
509   return 0;
510 }
511
512 int
513 acceptConn(struct fileId **sockId, struct ipAddr **addr)
514 {
515   union olsr_sockaddr sockAddr;
516   socklen_t len;
517   int sock;
518   int flags;
519
520   do {
521     len = sizeof(struct sockaddr_storage);
522
523     sock = accept(mainSocket, &sockAddr.in, &len);
524   }
525   while (sock < 0 && errno == EINTR);
526
527   if (sock < 0) {
528     if (errno != EAGAIN)
529       error("accept failed: %s\n", strerror(errno));
530
531     return -1;
532   }
533
534   flags = fcntl(sock, F_GETFL);
535
536   if (flags < 0) {
537     error("cannot get flags : %s\n", strerror(errno));
538     close(sock);
539     return -1;
540   }
541
542   if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
543     error("cannot set flags: %s\n", strerror(errno));
544     close(sock);
545     return -1;
546   }
547
548   *addr = allocMem(sizeof(struct ipAddr));
549
550   if (addrFromSockAddr(*addr, &sockAddr) < 0) {
551     error("cannot convert socket address\n");
552     freeMem(addr);
553     close(sock);
554     return -1;
555   }
556
557   *sockId = allocMem(sizeof(struct fileId));
558
559   (*sockId)->fileDesc = sock;
560
561   return 0;
562 }
563
564 void
565 closeMainSocket(void)
566 {
567   close(mainSocket);
568 }
569
570 int
571 waitForSockets(struct fileId *sockIds[], int *flags[], int num)
572 {
573   fd_set readSet, writeSet;
574   int i;
575   int fileDesc;
576   int max;
577   int res;
578
579   FD_ZERO(&readSet);
580   FD_ZERO(&writeSet);
581
582   FD_SET(mainSocket, &readSet);
583
584   max = mainSocket;
585
586   for (i = 0; i < num; i++) {
587     fileDesc = sockIds[i]->fileDesc;
588
589     if (fileDesc > max)
590       max = fileDesc;
591
592     if ((*flags[i] & FLAG_READ) != 0)
593       FD_SET(fileDesc, &readSet);
594
595     if ((*flags[i] & FLAG_WRITE) != 0)
596       FD_SET(fileDesc, &writeSet);
597   }
598
599   do
600     res = select(max + 1, &readSet, &writeSet, NULL, NULL);
601   while (res < 0 && errno == EINTR);
602
603   if (res < 0) {
604     error("cannot select: %s\n", strerror(errno));
605     return -1;
606   }
607
608   for (i = 0; i < num; i++) {
609     *flags[i] = 0;
610
611     fileDesc = sockIds[i]->fileDesc;
612
613     if (FD_ISSET(fileDesc, &readSet))
614       *flags[i] |= FLAG_READ;
615
616     if (FD_ISSET(fileDesc, &writeSet))
617       *flags[i] |= FLAG_WRITE;
618   }
619
620   return 0;
621 }
622
623 #endif /* __linux__ */
624
625 /*
626  * Local Variables:
627  * c-basic-offset: 2
628  * indent-tabs-mode: nil
629  * End:
630  */