Return to fwsync_workers.c CVS log

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

fix wrong allocated memory size

    1: /*************************************************************************
    2: * (C) 2022 CloudSigma AG - Sofia/Bulgaria
    3: *  by Michael Pounov <misho@elwix.org>
    4: **************************************************************************/
    5: #include "fwsync.h"
    6: 
    7: 
    8: void
    9: fwsync_sndpkt_handler(void *context, int pending)
   10: {
   11: 	struct fws_sndpkt *pkt;
   12: 	struct mbuf *m2, *m;
   13: 	int e;
   14: 
   15: 	DTRACE();
   16: 
   17: 	printf("pending=%d\n", pending);
   18: 
   19: 	do {
   20: 		mtx_lock(&fws_mtx_c);
   21: 		pkt = TAILQ_FIRST(&fwsync_sndpkt);
   22: 		if (pkt)
   23: 			TAILQ_REMOVE(&fwsync_sndpkt, pkt, sp_next);
   24: 		mtx_unlock(&fws_mtx_c);
   25: 
   26: 		if (!pkt)	/* sending queue is empty */
   27: 			break;
   28: 
   29: 		if (!(fws_cfg.cfg.on & CFG_SYNC_COLLECTOR)) {
   30: 			free(pkt, M_FWSYNC);
   31: 			continue;
   32: 		}
   33: 
   34: 		m = m_gethdr(M_NOWAIT, MT_DATA);
   35: 		if (!m) {
   36: 			free(pkt, M_FWSYNC);
   37: 			continue;
   38: 		}
   39: 
   40: 		memcpy(mtod(m, struct fws_proto *), &pkt->sp_proto, sizeof pkt->sp_proto);
   41: 		m->m_len = sizeof pkt->sp_proto;
   42: 		m_fixhdr(m);
   43: 
   44: 		if ((fws_ctx.config & (CTX_COLLECTOR_2_ONLINE | CTX_COLLECTOR_2_READY)) == 
   45: 				(CTX_COLLECTOR_2_ONLINE | CTX_COLLECTOR_2_READY)) {
   46: 			m2 = m_copypacket(m, M_NOWAIT);
   47: 			if (!m2) {
   48: 				printf("error in copypacket for second collector\n");
   49: 				goto out;
   50: 			}
   51: 			e = sosend(fws_ctx.sockz[CFG_SYNC_ADDR_COLLECTOR_2], 
   52: 					&fws_cfg.cfg_addr[CFG_SYNC_ADDR_COLLECTOR_2].addr, NULL, 
   53: 					m2, NULL, 0, curthread);
   54: 			if (e && e != EAGAIN)
   55: 				printf("error in collector %d handler #%d\n", CFG_SYNC_ADDR_COLLECTOR_2, e);
   56: 		}
   57: 
   58: 		if ((fws_ctx.config & (CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_1_READY)) == 
   59: 				(CTX_COLLECTOR_1_ONLINE | CTX_COLLECTOR_1_READY)) {
   60: 			m2 = m_copypacket(m, M_NOWAIT);
   61: 			if (!m2) {
   62: 				printf("error in copypacket for first collector\n");
   63: 				goto out;
   64: 			}
   65: 			e = sosend(fws_ctx.sockz[CFG_SYNC_ADDR_COLLECTOR_1], 
   66: 					&fws_cfg.cfg_addr[CFG_SYNC_ADDR_COLLECTOR_1].addr, NULL, 
   67: 					m2, NULL, 0, curthread);
   68: 			if (e && e != EAGAIN)
   69: 				printf("error in collector %d handler #%d\n", CFG_SYNC_ADDR_COLLECTOR_1, e);
   70: 		}
   71: out:
   72: 		m_freem(m);
   73: 		free(pkt, M_FWSYNC);
   74: 	} while (--pending);
   75: }
   76: 
   77: int
   78: fwsync_state_handler(const void *arg)
   79: {
   80: 	const struct ipfw_flow_id *pkt = arg;
   81: 	struct fws_proto *spkt;
   82: 	struct fws_sndpkt *p;
   83: 
   84: 	DTRACE();
   85: 
   86: 	if (!pkt || pkt->addr_type == 1)
   87: 		return 0;	/* skip ethernet packet */
   88: 
   89: 	mtx_lock(&fws_mtx_c);
   90: 
   91: 	p = malloc(sizeof(struct fws_sndpkt), M_FWSYNC, M_NOWAIT | M_ZERO);
   92: 	if (!p) {
   93: 		mtx_unlock(&fws_mtx_c);
   94: 		return 0;
   95: 	} else
   96: 		spkt = &p->sp_proto;
   97: 
   98: 	spkt->fws_version = FWS_PKTVER_STATE;
   99: 	spkt->fws_fib = pkt->fib;
  100: 	spkt->fws_proto = pkt->proto;
  101: 	spkt->fws_addrtype = pkt->addr_type;
  102: 	spkt->fws_sport = pkt->src_port;
  103: 	spkt->fws_dport = pkt->dst_port;
  104: 
  105: 	switch (pkt->addr_type) {
  106: 		case 4:
  107: 			spkt->fws_saddr.s_addr = pkt->src_ip;
  108: 			spkt->fws_daddr.s_addr = pkt->dst_ip;
  109: 			spkt->fws_scopeid = 0;
  110: 			break;
  111: 		case 6:
  112: 			memcpy(&spkt->fws_saddr6, &pkt->src_ip6, sizeof spkt->fws_saddr6);
  113: 			memcpy(&spkt->fws_daddr6, &pkt->dst_ip6, sizeof spkt->fws_daddr6);
  114: 			spkt->fws_scopeid = pkt->flow_id6;
  115: 			break;
  116: 		default:
  117: 			free(p, M_FWSYNC);
  118: 			mtx_unlock(&fws_mtx_c);
  119: 			return EINVAL;
  120: 	}
  121: 
  122: 	TAILQ_INSERT_TAIL(&fwsync_sndpkt, p, sp_next);
  123: 
  124: 	mtx_unlock(&fws_mtx_c);
  125: 
  126: 	taskqueue_enqueue(fws_tq, &fws_sndpkt_task);
  127: 	return 0;
  128: }
  129: 
  130: int
  131: fwsync_alias_handler(const void *arg)
  132: {
  133: 	const struct alias_link *lnk = arg;
  134: 	struct fws_proto *spkt;
  135: 	struct fws_sndpkt *p;
  136: 
  137: 	DTRACE();
  138: 
  139: 	if (!lnk || lnk->link_type >= IPPROTO_MAX)
  140: 		return 0;
  141: 
  142: 	mtx_lock(&fws_mtx_c);
  143: 
  144: 	p = malloc(sizeof(struct fws_sndpkt), M_FWSYNC, M_NOWAIT | M_ZERO);
  145: 	if (!p) {
  146: 		mtx_unlock(&fws_mtx_c);
  147: 		return 0;
  148: 	} else
  149: 		spkt = &p->sp_proto;
  150: 
  151: 	spkt->fws_version = FWS_PKTVER_ALIAS;
  152: 	spkt->fws_proto = lnk->link_type;
  153: 	spkt->fws_addrtype = 4;
  154: 	spkt->fws_sport = lnk->src_port;
  155: 	spkt->fws_dport = lnk->dst_port;
  156: 	spkt->fws_aport = lnk->alias_port;
  157: 	spkt->fws_pport = lnk->proxy_port;
  158: 	spkt->fws_saddr.s_addr = lnk->src_addr.s_addr;
  159: 	spkt->fws_daddr.s_addr = lnk->dst_addr.s_addr;
  160: 	spkt->fws_aaddr.s_addr = lnk->alias_addr.s_addr;
  161: 	spkt->fws_paddr.s_addr = lnk->proxy_addr.s_addr;
  162: 
  163: 	TAILQ_INSERT_TAIL(&fwsync_sndpkt, p, sp_next);
  164: 
  165: 	mtx_unlock(&fws_mtx_c);
  166: 
  167: 	taskqueue_enqueue(fws_tq, &fws_sndpkt_task);
  168: 	return 0;
  169: }