Return to fwsync_workers.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / fwsync / driver

Annotation of fwsync/driver/fwsync_workers.c, revision 1.1.1.1

1.1       misho       1: /*************************************************************************
                      2: * (C) 2022 CloudSigma AG - Sofia/Bulgaria
                      3: *  by Michael Pounov <misho@elwix.org>
                      4: **************************************************************************/
                      5: #include "fwsync.h"
                      6: 
                      7: 
                      8: static void
                      9: fwsync_sndpkt(void *context, int pending)
                     10: {
                     11:        struct mbuf *m2, *m = (struct mbuf*) context;
                     12:        int e;
                     13: 
                     14:        DTRACE();
                     15: 
                     16:        if (fws_cfg.cfg.on & CFG_SYNC_COLLECTOR) {
                     17:                if ((fws_ctx.config & (CTX_COLLECTOR_2_ONLINE | CTX_COLLECTOR_2_READY)) == 
                     18:                                (CTX_COLLECTOR_2_ONLINE | CTX_COLLECTOR_2_READY)) {
                     19:                        m2 = m_copypacket(m, M_NOWAIT);
                     20:                        if (!m2) {
                     21:                                printf("error in copypacket for second collector\n");
                     22:                                goto out;
                     23:                        }
                     24:                        e = sosend(fws_ctx.sockz[CFG_SYNC_ADDR_COLLECTOR_2], 
                     25:                                        &fws_cfg.cfg_addr[CFG_SYNC_ADDR_COLLECTOR_2].addr, NULL, 
                     26:                                        m2, NULL, 0, curthread);
                     27:                        if (e != EAGAIN)
                     28:                                printf("error in collector %d handler #%d\n", CFG_SYNC_ADDR_COLLECTOR_2, e);
                     29:                }
                     30: 
                     31:                if ((fws_ctx.config & (CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_1_READY)) == 
                     32:                                (CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_1_READY)) {
                     33:                        m2 = m_copypacket(m, M_NOWAIT);
                     34:                        if (!m2) {
                     35:                                printf("error in copypacket for first collector\n");
                     36:                                goto out;
                     37:                        }
                     38:                        e = sosend(fws_ctx.sockz[CFG_SYNC_ADDR_COLLECTOR_1], 
                     39:                                        &fws_cfg.cfg_addr[CFG_SYNC_ADDR_COLLECTOR_1].addr, NULL, 
                     40:                                        m2, NULL, 0, curthread);
                     41:                        if (e != EAGAIN)
                     42:                                printf("error in collector %d handler #%d\n", CFG_SYNC_ADDR_COLLECTOR_1, e);
                     43:                }
                     44:        }
                     45: out:
                     46:        m_freem(m);
                     47: 
                     48: }
                     49: 
                     50: int
                     51: fwsync_state_handler(const void *arg)
                     52: {
                     53:        const struct ipfw_flow_id *pkt = arg;
                     54:        struct fws_proto *spkt;
                     55:        struct mbuf *m;
                     56: 
                     57:        DTRACE();
                     58: 
                     59:        if (pkt->addr_type == 1)
                     60:                return 0;       /* skip ethernet packet */
                     61: 
                     62:        m = m_gethdr(M_WAITOK, MT_DATA);
                     63:        if (!m)
                     64:                return ENOMEM;
                     65:        else {
                     66:                spkt = mtod(m, struct fws_proto *);
                     67:                m->m_len = sizeof(struct fws_proto);
                     68:                m_fixhdr(m);
                     69:        }
                     70: 
                     71:        spkt->fws_version = FWS_PKTVER_STATE;
                     72:        spkt->fws_fib = pkt->fib;
                     73:        spkt->fws_proto = pkt->proto;
                     74:        spkt->fws_addrtype = pkt->addr_type;
                     75:        spkt->fws_sport = pkt->src_port;
                     76:        spkt->fws_dport = pkt->dst_port;
                     77: 
                     78:        switch (pkt->addr_type) {
                     79:                case 4:
                     80:                        spkt->fws_saddr.s_addr = pkt->src_ip;
                     81:                        spkt->fws_daddr.s_addr = pkt->dst_ip;
                     82:                        spkt->fws_scopeid = 0;
                     83:                        break;
                     84:                case 6:
                     85:                        memcpy(&spkt->fws_saddr6, &pkt->src_ip6, sizeof spkt->fws_saddr6);
                     86:                        memcpy(&spkt->fws_daddr6, &pkt->dst_ip6, sizeof spkt->fws_daddr6);
                     87:                        spkt->fws_scopeid = pkt->flow_id6;
                     88:                        break;
                     89:                default:
                     90:                        m_free(m);
                     91:                        return 0;
                     92:        }
                     93: 
                     94:        TASK_INIT(&fws_sndpkt_task, 0, fwsync_sndpkt, m);
                     95:        taskqueue_enqueue(taskqueue_thread, &fws_sndpkt_task);
                     96:        return 0;
                     97: }
                     98: 
                     99: int
                    100: fwsync_alias_handler(const void *arg)
                    101: {
                    102:        DTRACE();
                    103: 
                    104:        return 0;
                    105: }