ldpd/accept.c

   1 /*      $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2012 Claudio Jeker <claudio@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <zebra.h>
  20
  21 #include "ldpd.h"
  22 #include "ldpe.h"
  23 #include "log.h"
  24
  25 struct accept_ev {
  26         LIST_ENTRY(accept_ev)    entry;
  27         struct thread           *ev;
  28         int                     (*accept_cb)(struct thread *);
  29         void                    *arg;
  30         int                      fd;
  31 };
  32
  33 struct {
  34         LIST_HEAD(, accept_ev)   queue;
  35         struct thread           *evt;
  36 } accept_queue;
  37
  38 static void     accept_arm(void);
  39 static void     accept_unarm(void);
  40 static int      accept_cb(struct thread *);
  41 static int      accept_timeout(struct thread *);
  42
  43 void
  44 accept_init(void)
  45 {
  46         LIST_INIT(&accept_queue.queue);
  47 }
  48
  49 int
  50 accept_add(int fd, int (*cb)(struct thread *), void *arg)
  51 {
  52         struct accept_ev        *av;
  53
  54         if ((av = calloc(1, sizeof(*av))) == NULL)
  55                 return (-1);
  56         av->fd = fd;
  57         av->accept_cb = cb;
  58         av->arg = arg;
  59         LIST_INSERT_HEAD(&accept_queue.queue, av, entry);
  60
  61         av->ev = NULL;
  62         thread_add_read(master, accept_cb, av, av->fd, &av->ev);
  63
  64         log_debug("%s: accepting on fd %d", __func__, fd);
  65
  66         return (0);
  67 }
  68
  69 void
  70 accept_del(int fd)
  71 {
  72         struct accept_ev        *av;
  73
  74         LIST_FOREACH(av, &accept_queue.queue, entry)
  75                 if (av->fd == fd) {
  76                         log_debug("%s: %d removed from queue", __func__, fd);
  77                         THREAD_READ_OFF(av->ev);
  78                         LIST_REMOVE(av, entry);
  79                         free(av);
  80                         return;
  81                 }
  82 }
  83
  84 void
  85 accept_pause(void)
  86 {
  87         log_debug(__func__);
  88         accept_unarm();
  89         accept_queue.evt = NULL;
  90         thread_add_timer(master, accept_timeout, NULL, 1, &accept_queue.evt);
  91 }
  92
  93 void
  94 accept_unpause(void)
  95 {
  96         if (accept_queue.evt != NULL) {
  97                 log_debug(__func__);
  98                 THREAD_TIMER_OFF(accept_queue.evt);
  99                 accept_arm();
 100         }
 101 }
 102
 103 static void
 104 accept_arm(void)
 105 {
 106         struct accept_ev        *av;
 107         LIST_FOREACH(av, &accept_queue.queue, entry) {
 108                 av->ev = NULL;
 109                 thread_add_read(master, accept_cb, av, av->fd, &av->ev);
 110         }
 111 }
 112
 113 static void
 114 accept_unarm(void)
 115 {
 116         struct accept_ev        *av;
 117         LIST_FOREACH(av, &accept_queue.queue, entry)
 118                 THREAD_READ_OFF(av->ev);
 119 }
 120
 121 static int
 122 accept_cb(struct thread *thread)
 123 {
 124         struct accept_ev        *av = THREAD_ARG(thread);
 125         av->ev = NULL;
 126         thread_add_read(master, accept_cb, av, av->fd, &av->ev);
 127         av->accept_cb(thread);
 128
 129         return (0);
 130 }
 131
 132 static int
 133 accept_timeout(struct thread *thread)
 134 {
 135         accept_queue.evt = NULL;
 136
 137         log_debug(__func__);
 138         accept_arm();
 139
 140         return (0);
 141 }