usr.sbin/atm/atmarpd/atmarp_timer.c

   1 /*
   2  *
   3  * ===================================
   4  * HARP  |  Host ATM Research Platform
   5  * ===================================
   6  *
   7  *
   8  * This Host ATM Research Platform ("HARP") file (the "Software") is
   9  * made available by Network Computing Services, Inc. ("NetworkCS")
  10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
  11  * support of any kind.
  12  *
  13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
  14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
  15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
  16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
  17  * In no event shall NetworkCS be responsible for any damages, including
  18  * but not limited to consequential damages, arising from or relating to
  19  * any use of the Software or related support.
  20  *
  21  * Copyright 1994-1998 Network Computing Services, Inc.
  22  *
  23  * Copies of this Software may be made, however, the above copyright
  24  * notice must be reproduced on all copies.
  25  *
  26  *      @(#) $FreeBSD: src/usr.sbin/atm/atmarpd/atmarp_timer.c,v 1.3 1999/08/28 01:15:30 peter Exp $
  27  *      @(#) $DragonFly: src/usr.sbin/atm/atmarpd/atmarp_timer.c,v 1.2 2003/06/17 04:29:52 dillon Exp $
  28  */
  29
  30 /*
  31  * Server Cache Synchronization Protocol (SCSP) Support
  32  * ----------------------------------------------------
  33  *
  34  * SCSP-ATMARP server interface: timer routines
  35  *
  36  */
  37
  38 #include <sys/types.h>
  39 #include <sys/param.h>
  40 #include <sys/socket.h>
  41 #include <net/if.h>
  42 #include <netinet/in.h>
  43 #include <netatm/port.h>
  44 #include <netatm/queue.h>
  45 #include <netatm/atm.h>
  46 #include <netatm/atm_if.h>
  47 #include <netatm/atm_sap.h>
  48 #include <netatm/atm_sys.h>
  49 #include <netatm/atm_ioctl.h>
  50
  51 #include <errno.h>
  52 #include <libatm.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <syslog.h>
  57
  58 #include "../scspd/scsp_msg.h"
  59 #include "../scspd/scsp_if.h"
  60 #include "../scspd/scsp_var.h"
  61 #include "atmarp_var.h"
  62
  63 /*
  64  * Cache update timeout processing
  65  *
  66  * When the cache update timer fires, we read the cache from the
  67  * kernel, update the internal cache, and restart the timer.
  68  *
  69  * Arguments:
  70  *      tp      pointer to a HARP timer block
  71  *
  72  * Returns:
  73  *      None
  74  *
  75  */
  76 void
  77 atmarp_cache_timeout(tp)
  78         Harp_timer      *tp;
  79 {
  80         Atmarp_intf     *aip;
  81
  82         /*
  83          * Verify the status of all configured interfaces
  84          */
  85         for (aip = atmarp_intf_head; aip; aip = aip->ai_next) {
  86                 if (atmarp_if_ready(aip)) {
  87                         /*
  88                          * The interface is up but we don't have
  89                          * a connection to SCSP--make a connection
  90                          */
  91                         if (aip->ai_state == AI_STATE_NULL)
  92                                 (void)atmarp_scsp_connect(aip);
  93                 } else {
  94                         /*
  95                          * The interface is down--disconnect from SCSP
  96                          */
  97                         if (aip->ai_state != AI_STATE_NULL)
  98                                 (void)atmarp_scsp_disconnect(aip);
  99                 }
 100         }
 101
 102         /*
 103          * Read the cache from the kernel
 104          */
 105         atmarp_get_updated_cache();
 106
 107         /*
 108          * Restart the cache update timer
 109          */
 110         HARP_TIMER(tp, ATMARP_CACHE_INTERVAL, atmarp_cache_timeout);
 111 }
 112
 113
 114 /*
 115  * Permanent cache entry timer processing
 116  *
 117  * Permanent cache entries (entries that are administratively added
 118  * and the entry for the server itself) don't ever get refreshed, so
 119  * we broadcast updates for them every 10 minutes so they won't get
 120  * deleted from the remote servers' caches
 121  *
 122  * Arguments:
 123  *      tp      pointer to a HARP timer block
 124  *
 125  * Returns:
 126  *      None
 127  *
 128  */
 129 void
 130 atmarp_perm_timeout(tp)
 131         Harp_timer      *tp;
 132 {
 133         int             i, rc;
 134         Atmarp_intf     *aip;
 135         Atmarp          *aap;
 136
 137         /*
 138          * Loop through all interfaces
 139          */
 140         for (aip = atmarp_intf_head; aip; aip = aip->ai_next) {
 141                 /*
 142                  * Loop through the interface's cache
 143                  */
 144                 for (i = 0; i < ATMARP_HASHSIZ; i++) {
 145                         for (aap = aip->ai_arptbl[i]; aap;
 146                                         aap = aap->aa_next) {
 147                                 /*
 148                                  * Find and update permanent entries
 149                                  */
 150                                 if ((aap->aa_flags & (AAF_PERM |
 151                                                 AAF_SERVER)) != 0) {
 152                                         aap->aa_seq++;
 153                                         rc = atmarp_scsp_update(aap,
 154                                                 SCSP_ASTATE_UPD);
 155                                 }
 156                         }
 157                 }
 158         }
 159
 160         /*
 161          * Restart the permanent cache entry timer
 162          */
 163         HARP_TIMER(tp, ATMARP_PERM_INTERVAL, atmarp_perm_timeout);
 164 }
 165
 166
 167 /*
 168  * Keepalive timeout processing
 169  *
 170  * When the keepalive timer fires, we send a NOP to SCSP.  This
 171  * will help us detect a broken connection.
 172  *
 173  * Arguments:
 174  *      tp      pointer to a HARP timer block
 175  *
 176  * Returns:
 177  *      None
 178  *
 179  */
 180 void
 181 atmarp_keepalive_timeout(tp)
 182         Harp_timer      *tp;
 183 {
 184         Atmarp_intf     *aip;
 185         Scsp_if_msg     *msg;
 186
 187         /*
 188          * Back off to start of DCS entry
 189          */
 190         aip = (Atmarp_intf *) ((caddr_t)tp -
 191                         (int)(&((Atmarp_intf *)0)->ai_keepalive_t));
 192
 193         /*
 194          * Get a message buffer
 195          */
 196         msg = (Scsp_if_msg *)UM_ALLOC(sizeof(Scsp_if_msg));
 197         if (!msg) {
 198         }
 199         UM_ZERO(msg, sizeof(Scsp_if_msg));
 200
 201         /*
 202          * Build a NOP message
 203          */
 204         msg->si_type = SCSP_NOP_REQ;
 205         msg->si_proto = SCSP_PROTO_ATMARP;
 206         msg->si_len = sizeof(Scsp_if_msg_hdr);
 207
 208         /*
 209          * Send the message to SCSP
 210          */
 211         (void)atmarp_scsp_out(aip, (char *)msg, msg->si_len);
 212         UM_FREE(msg);
 213
 214         /*
 215          * Restart the keepalive timer
 216          */
 217         HARP_TIMER(&aip->ai_keepalive_t, ATMARP_KEEPALIVE_INTERVAL,
 218                         atmarp_keepalive_timeout);
 219 }