[BACK]Return to fwsync.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / fwsync / driver

Diff for /fwsync/driver/fwsync.c between versions 1.1 and 1.12.2.2

version 1.1, 2022/06/22 13:01:55 version 1.12.2.2, 2022/08/26 14:40:32
Line 1 Line 1
/*************************************************************************/*-
* (C) 2022 CloudSigma AG - Sofia/Bulgaria * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*  by Michael Pounov <misho@elwix.org> *
**************************************************************************/ * Copyright (c) 2022 Michael Pounov <misho@elwix.org>, CloudSigma AG
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include "fwsync.h"  #include "fwsync.h"
   
   
 static intptr_t fwsync_wchan;  
   
   
 static void  static void
 fwsync_edge_proc(void *arg)  fwsync_edge_proc(void *arg)
 {  {
        int e, rcvflg;        int e, rcvflg = 0;
         struct uio uio;          struct uio uio;
         struct mbuf *m = NULL;          struct mbuf *m = NULL;
           struct fws_proto *pkt;
   
         DTRACE();          DTRACE();
   
           callout_schedule(&fws_co, hz);
   
         memset(&uio, 0, sizeof uio);          memset(&uio, 0, sizeof uio);
         uio.uio_resid = 1000000000;          uio.uio_resid = 1000000000;
         uio.uio_td = curthread;          uio.uio_td = curthread;
   
        fws_ctx.config |= CTX_EDGE_ONLINE;        if ((fws_cfg.cfg.on & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_EDGE_READY)) {
        while ((fws_cfg.cfg.on & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_EDGE_READY)) { 
                if (m) 
                        m_freem(m); 
                m = NULL; 
                 rcvflg = MSG_DONTWAIT;                  rcvflg = MSG_DONTWAIT;
                 e = soreceive(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], NULL, &uio, &m, NULL, &rcvflg);                  e = soreceive(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], NULL, &uio, &m, NULL, &rcvflg);
                 if (e) {                  if (e) {
                         if (e != EAGAIN)                          if (e != EAGAIN)
                                 printf("error in edge handler #%d\n", e);                                  printf("error in edge handler #%d\n", e);
                        tsleep(&fwsync_wchan, 0, "edge_handler", hz);                        return;
                        continue; 
                 }                  }
                   pkt = mtod(m, struct fws_proto*);
                   if (m_length(m, NULL) != sizeof(struct fws_proto)) {
                           printf("FWSync packet length=%d isn't match expected %lu\n", 
                                           m_length(m, NULL), sizeof(struct fws_proto));
                           m_freem(m);
                           return;
                   }
   
                printf("%u...-> %s\n", m->m_len, m->m_data);                switch (pkt->fws_version) {
        }                        case FWS_PKTVER_STATE:
        fws_ctx.config &= ~CTX_EDGE_ONLINE;                                fwsync_add_state(pkt);
                                 break;
                         case FWS_PKTVER_ALIAS:
                                 fwsync_add_alias(pkt);
                                 break;
                         default:
                                 printf("FWSync packet was discarded due to wrong version\n");
                                 break;
                 }
   
        kproc_exit(0);                m_freem(m);
         }
 }  }
   
 int  int
Line 151  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader Line 184  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader
   
         n = (int*) (oh + 1);          n = (int*) (oh + 1);
         if (*n & CFG_SYNC_EDGE) {          if (*n & CFG_SYNC_EDGE) {
                   if (fws_ctx.config & CTX_EDGE_ONLINE) {
                           ipfw_unregister_state_sync();
                           ipfw_unregister_alias_sync();
                   }
   
                   callout_drain(&fws_co);
   
                 fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;                  fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;
                 fws_cfg.cfg.edge = 0;                  fws_cfg.cfg.edge = 0;
                 fws_cfg.cfg.addrs = 0;                  fws_cfg.cfg.addrs = 0;
                 memset(fws_cfg.cfg_addr, 0, sizeof fws_cfg.cfg_addr[0]);                  memset(fws_cfg.cfg_addr, 0, sizeof fws_cfg.cfg_addr[0]);
   
                if (fws_ctx.config & CTX_EDGE_READY) {                soshutdown(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], SHUT_RD);
                        soshutdown(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], SHUT_RD);                soclose(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE]);
                        tsleep(&fwsync_wchan, 0, "fwsedge_kill", 2 * hz); 
                        soclose(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE]); 
                } 
         }          }
         if (*n & CFG_SYNC_COLLECTOR) {          if (*n & CFG_SYNC_COLLECTOR) {
                 if (fws_ctx.config & (CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_2_ONLINE)) {                  if (fws_ctx.config & (CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_2_ONLINE)) {
Line 168  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader Line 205  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader
                         ipfw_unregister_alias_hook();                          ipfw_unregister_alias_hook();
                 }                  }
   
                   taskqueue_drain(fws_tq, &fws_sndpkt_task);
   
                 fws_cfg.cfg.on &= ~CFG_SYNC_COLLECTOR;                  fws_cfg.cfg.on &= ~CFG_SYNC_COLLECTOR;
                 fws_cfg.cfg.collector = 0;                  fws_cfg.cfg.collector = 0;
                 fws_cfg.cfg.addrs = 0;                  fws_cfg.cfg.addrs = 0;
Line 181  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader Line 220  fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader
   
         fws_ctx.config ^= fws_ctx.config;          fws_ctx.config ^= fws_ctx.config;
   
           memset(&fws_acct, 0, sizeof fws_acct);
   
         return 0;          return 0;
 }  }
   
Line 225  fwsync_get_cfg(struct ip_fw_chain *ch, ip_fw3_opheader Line 266  fwsync_get_cfg(struct ip_fw_chain *ch, ip_fw3_opheader
 int  int
 fwsync_list(struct ip_fw_chain *ch, ip_fw3_opheader *op3, struct sockopt_data *sd)  fwsync_list(struct ip_fw_chain *ch, ip_fw3_opheader *op3, struct sockopt_data *sd)
 {  {
           ipfw_obj_header *oh;
           struct ipfw_sync_cfg *ucfg;
           size_t sz;
   
         DTRACE();          DTRACE();
   
           sz = sizeof(*oh) + sizeof(*ucfg);
           /* Check minimum header size */
           if (sd->valsize < sz)
                   return (EINVAL);
   
           oh = (struct _ipfw_obj_header*) ipfw_get_sopt_header(sd, sz);
   
           /* Basic length checks for TLVs */
           if (oh->ntlv.head.length != sizeof(oh->ntlv))
                   return (EINVAL);
   
           ucfg = (struct ipfw_sync_cfg*) (oh + 1);
   
           /* Check if name is properly terminated */
           if (strnlen(ucfg->name, sizeof(ucfg->name)) == sizeof(ucfg->name))
                   return (EINVAL);
   
           ucfg->mode = 0;
           if (fws_cfg.cfg.edge)
                   ucfg->mode |= CFG_SYNC_EDGE;
           if (fws_cfg.cfg.collector)
                   ucfg->mode |= CFG_SYNC_COLLECTOR;
           ucfg->addrs = 2;
           memcpy(ucfg->addr[0].ip6.sin6_addr.s6_addr, &fws_acct.states[0], sizeof(uint64_t));
           memcpy(ucfg->addr[0].ip6.sin6_addr.s6_addr + 8, &fws_acct.states[1], sizeof(uint64_t));
           memcpy(ucfg->addr[1].ip6.sin6_addr.s6_addr, &fws_acct.aliases[0], sizeof(uint64_t));
           memcpy(ucfg->addr[1].ip6.sin6_addr.s6_addr + 8, &fws_acct.aliases[1], sizeof(uint64_t));
   
         return 0;          return 0;
 }  }
   
 int  int
 fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader *op3, struct sockopt_data *sd)  fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader *op3, struct sockopt_data *sd)
 {  {
        int *n, e;        int *n;
         ipfw_obj_header *oh;          ipfw_obj_header *oh;
         size_t sz;          size_t sz;
   
Line 255  fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader * Line 328  fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader *
         if ((*n & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_EDGE_READY)) {          if ((*n & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_EDGE_READY)) {
                 fws_cfg.cfg.on |= CFG_SYNC_EDGE;                  fws_cfg.cfg.on |= CFG_SYNC_EDGE;
   
                e = kproc_create(fwsync_edge_proc, NULL, &fws_ctx.procz[CFG_SYNC_ADDR_EDGE],                 callout_reset(&fws_co, hz, fwsync_edge_proc, NULL);
                                0, 0, "fwsync_edge");
                if (e) {                if (!(fws_ctx.config & CTX_EDGE_ONLINE)) {
                        printf("fwsync fwsync_edge failed #%d\n", e);                        ipfw_register_state_sync(fwsync_state_sync);
                        return e;                        ipfw_register_alias_sync(fwsync_alias_sync);
                 }                  }
   
                   fws_ctx.config |= CTX_EDGE_ONLINE;
         }          }
   
         if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_1_READY)) {          if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_1_READY)) {
Line 285  fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader * Line 360  fwsync_start(struct ip_fw_chain *ch, ip_fw3_opheader *
                 fws_ctx.config |= CTX_COLLECTOR_2_ONLINE;                  fws_ctx.config |= CTX_COLLECTOR_2_ONLINE;
         }          }
   
         /* at last but not at least, activate config status of started sync service */  
         fws_cfg.cfg.on |= *n;  
         return 0;          return 0;
 }  }
   
Line 312  fwsync_stop(struct ip_fw_chain *ch, ip_fw3_opheader *o Line 385  fwsync_stop(struct ip_fw_chain *ch, ip_fw3_opheader *o
   
         n = (int*) (oh + 1);          n = (int*) (oh + 1);
   
        if ((*n & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_CFG_EDGE))        if ((*n & CFG_SYNC_EDGE) && (fws_ctx.config & CTX_CFG_EDGE)) {
                 fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;                  fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;
                   fws_ctx.config &= ~CTX_EDGE_ONLINE;
   
                   callout_drain(&fws_co);
   
                   ipfw_unregister_state_sync();
                   ipfw_unregister_alias_sync();
           }
   
         if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_2_ONLINE))          if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_2_ONLINE))
                 fws_ctx.config &= ~CTX_COLLECTOR_2_ONLINE;                  fws_ctx.config &= ~CTX_COLLECTOR_2_ONLINE;
         if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_1_ONLINE))          if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_1_ONLINE))
Line 326  fwsync_stop(struct ip_fw_chain *ch, ip_fw3_opheader *o Line 406  fwsync_stop(struct ip_fw_chain *ch, ip_fw3_opheader *o
   
                 ipfw_unregister_state_hook();                  ipfw_unregister_state_hook();
                 ipfw_unregister_alias_hook();                  ipfw_unregister_alias_hook();
   
                   taskqueue_drain(fws_tq, &fws_sndpkt_task);
         }          }
   
         /* at last but not at least, stop sync service */  
         fws_cfg.cfg.on &= ~*n;  
         return 0;          return 0;
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.12.2.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>