crypto/dist/ipsec-tools/src/racoon/schedule.c

   1 /*      $NetBSD: schedule.c,v 1.6 2009/01/23 08:25:07 tteras Exp $      */
   2
   3 /*      $KAME: schedule.c,v 1.19 2001/11/05 10:53:19 sakane Exp $       */
   4
   5 /*
   6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   7  * Copyright (C) 2008 Timo Teras.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the project nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "config.h"
  36
  37 #include <sys/types.h>
  38 #include <sys/param.h>
  39 #include <sys/time.h>
  40 #include <sys/queue.h>
  41 #include <sys/socket.h>
  42
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <errno.h>
  48 #include <time.h>
  49
  50 #include "misc.h"
  51 #include "plog.h"
  52 #include "schedule.h"
  53 #include "var.h"
  54 #include "gcmalloc.h"
  55
  56 #ifndef TAILQ_FOREACH
  57 #define TAILQ_FOREACH(elm, head, field) \
  58         for (elm = TAILQ_FIRST(head); elm; elm = TAILQ_NEXT(elm, field))
  59 #endif
  60
  61 static TAILQ_HEAD(_schedtree, sched) sctree;
  62
  63 void
  64 sched_get_monotonic_time(tv)
  65         struct timeval *tv;
  66 {
  67 #ifdef HAVE_CLOCK_MONOTONIC
  68         struct timespec ts;
  69
  70         clock_gettime(CLOCK_MONOTONIC, &ts);
  71         tv->tv_sec = ts.tv_sec;
  72         tv->tv_usec = ts.tv_nsec / 1000;
  73 #else
  74         gettimeofday(tv, NULL);
  75 #endif
  76 }
  77
  78 time_t
  79 sched_monotonic_to_time_t(tv, now)
  80         struct timeval *tv, *now;
  81 {
  82 #ifdef HAVE_CLOCK_MONOTONIC
  83         struct timeval mynow, res;
  84
  85         if (now == NULL) {
  86                 sched_get_monotonic_time(&mynow);
  87                 now = &mynow;
  88         }
  89         timersub(now, tv, &res);
  90
  91         return time(NULL) + res.tv_sec;
  92 #else
  93         return tv->tv_sec;
  94 #endif
  95 }
  96
  97 /*
  98  * schedule handler
  99  * OUT:
 100  *      time to block until next event.
 101  *      if no entry, NULL returned.
 102  */
 103 struct timeval *
 104 schedular()
 105 {
 106         static struct timeval timeout;
 107         struct timeval now;
 108         struct sched *p;
 109
 110         sched_get_monotonic_time(&now);
 111         while (!TAILQ_EMPTY(&sctree) &&
 112                 timercmp(&TAILQ_FIRST(&sctree)->xtime, &now, <=)) {
 113                 void (*func)(struct sched *);
 114
 115                 p = TAILQ_FIRST(&sctree);
 116                 func = p->func;
 117                 sched_cancel(p);
 118                 func(p);
 119         }
 120
 121         p = TAILQ_FIRST(&sctree);
 122         if (p == NULL)
 123                 return NULL;
 124
 125         timersub(&p->xtime, &now, &timeout);
 126
 127         return &timeout;
 128 }
 129
 130 /*
 131  * add new schedule to schedule table.
 132  */
 133 void
 134 sched_schedule(sc, tick, func)
 135         struct sched *sc;
 136         time_t tick;
 137         void (*func) __P((struct sched *));
 138 {
 139         static long id = 1;
 140         struct sched *p;
 141         struct timeval now;
 142
 143         sched_cancel(sc);
 144
 145         sc->func = func;
 146         sc->id = id++;
 147         sc->tick.tv_sec = tick;
 148         sc->tick.tv_usec = 0;
 149         sched_get_monotonic_time(&now);
 150         timeradd(&now, &sc->tick, &sc->xtime);
 151
 152         /* add to schedule table */
 153         TAILQ_FOREACH(p, &sctree, chain) {
 154                 if (timercmp(&sc->xtime, &p->xtime, <))
 155                         break;
 156         }
 157         if (p == NULL)
 158                 TAILQ_INSERT_TAIL(&sctree, sc, chain);
 159         else
 160                 TAILQ_INSERT_BEFORE(p, sc, chain);
 161 }
 162
 163 /*
 164  * cancel scheduled callback
 165  */
 166 void
 167 sched_cancel(sc)
 168         struct sched *sc;
 169 {
 170         if (sc->func != NULL) {
 171                 TAILQ_REMOVE(&sctree, sc, chain);
 172                 sc->func = NULL;
 173         }
 174 }
 175
 176 /*
 177  * for debug
 178  */
 179 int
 180 sched_dump(buf, len)
 181         caddr_t *buf;
 182         int *len;
 183 {
 184         caddr_t new;
 185         struct sched *p;
 186         struct scheddump *dst;
 187         struct timeval now, created;
 188         int cnt = 0;
 189
 190         /* initialize */
 191         *len = 0;
 192         *buf = NULL;
 193
 194         TAILQ_FOREACH(p, &sctree, chain)
 195                 cnt++;
 196
 197         /* no entry */
 198         if (cnt == 0)
 199                 return -1;
 200
 201         *len = cnt * sizeof(*dst);
 202
 203         new = racoon_malloc(*len);
 204         if (new == NULL)
 205                 return -1;
 206         dst = (struct scheddump *)new;
 207
 208         sched_get_monotonic_time(&now);
 209         p = TAILQ_FIRST(&sctree);
 210         while (p) {
 211                 timersub(&p->xtime, &p->tick, &created);
 212                 dst->xtime = p->xtime.tv_sec;
 213                 dst->id = p->id;
 214                 dst->created = sched_monotonic_to_time_t(&created, &now);
 215                 dst->tick = p->tick.tv_sec;
 216
 217                 p = TAILQ_NEXT(p, chain);
 218                 if (p == NULL)
 219                         break;
 220                 dst++;
 221         }
 222
 223         *buf = new;
 224
 225         return 0;
 226 }
 227
 228 /* initialize schedule table */
 229 void
 230 sched_init()
 231 {
 232         TAILQ_INIT(&sctree);
 233 }
 234
 235 #ifdef STEST
 236 #include <sys/types.h>
 237 #include <sys/time.h>
 238 #include <unistd.h>
 239 #include <err.h>
 240
 241 void
 242 test(tick)
 243         int *tick;
 244 {
 245         printf("execute %d\n", *tick);
 246         racoon_free(tick);
 247 }
 248
 249 void
 250 getstdin()
 251 {
 252         int *tick;
 253         char buf[16];
 254
 255         read(0, buf, sizeof(buf));
 256         if (buf[0] == 'd') {
 257                 struct scheddump *scbuf, *p;
 258                 int len;
 259                 sched_dump((caddr_t *)&scbuf, &len);
 260                 if (scbuf == NULL)
 261                         return;
 262                 for (p = scbuf; len; p++) {
 263                         printf("xtime=%ld\n", p->xtime);
 264                         len -= sizeof(*p);
 265                 }
 266                 racoon_free(scbuf);
 267                 return;
 268         }
 269
 270         tick = (int *)racoon_malloc(sizeof(*tick));
 271         *tick = atoi(buf);
 272         printf("new queue tick = %d\n", *tick);
 273         sched_new(*tick, test, tick);
 274 }
 275
 276 int
 277 main()
 278 {
 279         static fd_set mask0;
 280         int nfds = 0;
 281         fd_set rfds;
 282         struct timeval *timeout;
 283         int error;
 284
 285         FD_ZERO(&mask0);
 286         FD_SET(0, &mask0);
 287         nfds = 1;
 288
 289         /* initialize */
 290         sched_init();
 291
 292         while (1) {
 293                 rfds = mask0;
 294
 295                 timeout = schedular();
 296
 297                 error = select(nfds, &rfds, (fd_set *)0, (fd_set *)0, timeout);
 298                 if (error < 0) {
 299                         switch (errno) {
 300                         case EINTR: continue;
 301                         default:
 302                                 err(1, "select");
 303                         }
 304                         /*NOTREACHED*/
 305                 }
 306
 307                 if (FD_ISSET(0, &rfds))
 308                         getstdin();
 309         }
 310 }
 311 #endif