Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/mrouted/igmp.c	Lines:	0	157	0.0 %
Date:	2017-11-07	Branches:	0	79	0.0 %


/*	$NetBSD: igmp.c,v 1.5 1995/12/10 10:07:01 mycroft Exp $	*/

/*
 * The mrouted program is covered by the license in the accompanying file
 * named "LICENSE".  Use of the mrouted program represents acceptance of
 * the terms and conditions listed in that file.
 *
 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
 * Leland Stanford Junior University.
 */


#include "defs.h"


/*
 * Exported variables.
 */
char		*recv_buf;		     /* input packet buffer         */
char		*send_buf;		     /* output packet buffer        */
int		igmp_socket;		     /* socket for all network I/O  */
u_int32_t	allhosts_group;		     /* All hosts addr in net order */
u_int32_t	allrtrs_group;		     /* All-Routers "  in net order */
u_int32_t	dvmrp_group;		     /* DVMRP grp addr in net order */
u_int32_t	dvmrp_genid;		     /* IGMP generation id          */

/*
 * Local function definitions.
 */
/* u_char promoted to u_int */
static char *	packet_kind(u_int type, u_int code);
static int	igmp_log_level(u_int type, u_int code);

/*
 * Open and initialize the igmp socket, and fill in the non-changing
 * IP header fields in the output packet buffer.
 */
void
init_igmp(void)
{
    struct ip *ip;

    recv_buf = malloc(RECV_BUF_SIZE);
    send_buf = malloc(RECV_BUF_SIZE);

    if ((igmp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP)) < 0)
	logit(LOG_ERR, errno, "IGMP socket");

    k_hdr_include(TRUE);	/* include IP header when sending */
    k_set_rcvbuf(48*1024);	/* lots of input buffering        */
    k_set_ttl(1);		/* restrict multicasts to one hop */
    k_set_loop(FALSE);		/* disable multicast loopback     */

    ip         = (struct ip *)send_buf;
    ip->ip_hl  = sizeof(struct ip) >> 2;
    ip->ip_v   = IPVERSION;
    ip->ip_tos = 0;
    ip->ip_off = htons(0);
    ip->ip_p   = IPPROTO_IGMP;
    ip->ip_ttl = MAXTTL;	/* applies to unicasts only */

    allhosts_group = htonl(INADDR_ALLHOSTS_GROUP);
    dvmrp_group    = htonl(INADDR_DVMRP_GROUP);
    allrtrs_group  = htonl(INADDR_ALLRTRS_GROUP);
}

#define PIM_QUERY        0
#define PIM_REGISTER     1
#define PIM_REGISTER_STOP	2
#define PIM_JOIN_PRUNE   3
#define PIM_RP_REACHABLE 4
#define PIM_ASSERT       5
#define PIM_GRAFT        6
#define PIM_GRAFT_ACK    7

static char *
packet_kind(u_int type, u_int code)
{
    switch (type) {
	case IGMP_HOST_MEMBERSHIP_QUERY:	return "membership query  ";
	case IGMP_v1_HOST_MEMBERSHIP_REPORT:	return "v1 member report  ";
	case IGMP_v2_HOST_MEMBERSHIP_REPORT:	return "v2 member report  ";
	case IGMP_HOST_LEAVE_MESSAGE:           return "leave message     ";
	case IGMP_DVMRP:
	  switch (code) {
	    case DVMRP_PROBE:			return "neighbor probe    ";
	    case DVMRP_REPORT:			return "route report      ";
	    case DVMRP_ASK_NEIGHBORS:		return "neighbor request  ";
	    case DVMRP_NEIGHBORS:		return "neighbor list     ";
	    case DVMRP_ASK_NEIGHBORS2:		return "neighbor request 2";
	    case DVMRP_NEIGHBORS2:		return "neighbor list 2   ";
	    case DVMRP_PRUNE:			return "prune message     ";
	    case DVMRP_GRAFT:			return "graft message     ";
	    case DVMRP_GRAFT_ACK:		return "graft message ack ";
	    case DVMRP_INFO_REQUEST:		return "info request      ";
	    case DVMRP_INFO_REPLY:		return "info reply        ";
	    default:				return "unknown DVMRP msg ";
	  }
	case IGMP_PIM:
	  switch (code) {
	    case PIM_QUERY:			return "PIM Router-Query  ";
	    case PIM_REGISTER:			return "PIM Register      ";
	    case PIM_REGISTER_STOP:		return "PIM Register-Stop ";
	    case PIM_JOIN_PRUNE:		return "PIM Join/Prune    ";
	    case PIM_RP_REACHABLE:		return "PIM RP-Reachable  ";
	    case PIM_ASSERT:			return "PIM Assert        ";
	    case PIM_GRAFT:			return "PIM Graft         ";
	    case PIM_GRAFT_ACK:			return "PIM Graft-Ack     ";
	    default:				return "unknown PIM msg   ";
	  }
	case IGMP_MTRACE_QUERY:			return "IGMP trace query  ";
	case IGMP_MTRACE_REPLY:			return "IGMP trace reply  ";
	default:				return "unknown IGMP msg  ";
    }
}

/*
 * Process a newly received IGMP packet that is sitting in the input
 * packet buffer.
 */
void
accept_igmp(int recvlen)
{
    u_int32_t src, dst, group;
    struct ip *ip;
    struct igmp *igmp;
    int ipdatalen, iphdrlen, igmpdatalen;

    if (recvlen < sizeof(struct ip)) {
	logit(LOG_WARNING, 0,
	    "received packet too short (%u bytes) for IP header", recvlen);
	return;
    }

    ip        = (struct ip *)recv_buf;
    src       = ip->ip_src.s_addr;
    dst       = ip->ip_dst.s_addr;

    /*
     * this is most likely a message from the kernel indicating that
     * a new src grp pair message has arrived and so, it would be
     * necessary to install a route into the kernel for this.
     */
    if (ip->ip_p == 0) {
	if (src == 0 || dst == 0)
	    logit(LOG_WARNING, 0, "kernel request not accurate");
	else
	    add_table_entry(src, dst);
	return;
    }

    iphdrlen  = ip->ip_hl << 2;
    ipdatalen = ntohs(ip->ip_len) - iphdrlen;
    if (iphdrlen + ipdatalen != recvlen) {
	logit(LOG_WARNING, 0,
	    "received packet from %s shorter (%u bytes) than hdr+data length (%u+%u)",
	    inet_fmt(src, s1), recvlen, iphdrlen, ipdatalen);
	return;
    }

    igmp        = (struct igmp *)(recv_buf + iphdrlen);
    group       = igmp->igmp_group.s_addr;
    igmpdatalen = ipdatalen - IGMP_MINLEN;
    if (igmpdatalen < 0) {
	logit(LOG_WARNING, 0,
	    "received IP data field too short (%u bytes) for IGMP, from %s",
	    ipdatalen, inet_fmt(src, s1));
	return;
    }

    logit(LOG_DEBUG, 0, "RECV %s from %-15s to %s",
	packet_kind(igmp->igmp_type, igmp->igmp_code),
	inet_fmt(src, s1), inet_fmt(dst, s2));

    switch (igmp->igmp_type) {

	case IGMP_HOST_MEMBERSHIP_QUERY:
	    accept_membership_query(src, dst, group, igmp->igmp_code);
	    return;

	case IGMP_v1_HOST_MEMBERSHIP_REPORT:
	case IGMP_v2_HOST_MEMBERSHIP_REPORT:
	    accept_group_report(src, dst, group, igmp->igmp_type);
	    return;

	case IGMP_HOST_LEAVE_MESSAGE:
	    accept_leave_message(src, dst, group);
	    return;

	case IGMP_DVMRP:
	    group = ntohl(group);

	    switch (igmp->igmp_code) {
		case DVMRP_PROBE:
		    accept_probe(src, dst,
				 (char *)(igmp+1), igmpdatalen, group);
		    return;

		case DVMRP_REPORT:
		    accept_report(src, dst,
				  (char *)(igmp+1), igmpdatalen, group);
		    return;

		case DVMRP_ASK_NEIGHBORS:
		    accept_neighbor_request(src, dst);
		    return;

		case DVMRP_ASK_NEIGHBORS2:
		    accept_neighbor_request2(src, dst);
		    return;

		case DVMRP_NEIGHBORS:
		    accept_neighbors(src, dst, (u_char *)(igmp+1), igmpdatalen,
					     group);
		    return;

		case DVMRP_NEIGHBORS2:
		    accept_neighbors2(src, dst, (u_char *)(igmp+1), igmpdatalen,
					     group);
		    return;

		case DVMRP_PRUNE:
		    accept_prune(src, dst, (char *)(igmp+1), igmpdatalen);
		    return;

		case DVMRP_GRAFT:
		    accept_graft(src, dst, (char *)(igmp+1), igmpdatalen);
		    return;

		case DVMRP_GRAFT_ACK:
		    accept_g_ack(src, dst, (char *)(igmp+1), igmpdatalen);
		    return;

		case DVMRP_INFO_REQUEST:
		    accept_info_request(src, dst, (char *)(igmp+1),
				igmpdatalen);
		    return;

		case DVMRP_INFO_REPLY:
		    accept_info_reply(src, dst, (char *)(igmp+1), igmpdatalen);
		    return;

		default:
		    logit(LOG_INFO, 0,
		     "ignoring unknown DVMRP message code %u from %s to %s",
		     igmp->igmp_code, inet_fmt(src, s1),
		     inet_fmt(dst, s2));
		    return;
	    }

	case IGMP_PIM:
	    return;

	case IGMP_MTRACE_REPLY:
	    return;

	case IGMP_MTRACE_QUERY:
	    accept_mtrace(src, dst, group, (char *)(igmp+1),
		   igmp->igmp_code, igmpdatalen);
	    return;

	default:
	    logit(LOG_INFO, 0,
		"ignoring unknown IGMP message type %x from %s to %s",
		igmp->igmp_type, inet_fmt(src, s1),
		inet_fmt(dst, s2));
	    return;
    }
}

/*
 * Some IGMP messages are more important than others.  This routine
 * determines the logging level at which to log a send error (often
 * "No route to host").  This is important when there is asymmetric
 * reachability and someone is trying to, i.e., mrinfo me periodically.
 */
static int
igmp_log_level(u_int type, u_int code)
{
    switch (type) {
	case IGMP_MTRACE_REPLY:
	    return LOG_INFO;

	case IGMP_DVMRP:
	  switch (code) {
	    case DVMRP_NEIGHBORS:
	    case DVMRP_NEIGHBORS2:
		return LOG_INFO;
	  }
    }
    return LOG_WARNING;
}

/*
 * Construct an IGMP message in the output packet buffer.  The caller may
 * have already placed data in that buffer, of length 'datalen'.  Then send
 * the message from the interface with IP address 'src' to destination 'dst'.
 */
void
send_igmp(u_int32_t src, u_int32_t dst, int type, int code,
    u_int32_t group, int datalen)
{
    struct sockaddr_in sdst;
    struct ip *ip;
    struct igmp *igmp;
    int setloop = 0;

    ip                      = (struct ip *)send_buf;
    ip->ip_src.s_addr       = src;
    ip->ip_dst.s_addr       = dst;
    ip->ip_len              = htons(MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen);

    igmp                    = (struct igmp *)(send_buf + MIN_IP_HEADER_LEN);
    igmp->igmp_type         = type;
    igmp->igmp_code         = code;
    igmp->igmp_group.s_addr = group;
    igmp->igmp_cksum        = 0;
    igmp->igmp_cksum        = inet_cksum((u_int16_t *)igmp,
					 IGMP_MINLEN + datalen);

    if (IN_MULTICAST(ntohl(dst))) {
	k_set_if(src);
	if (type != IGMP_DVMRP) {
	    setloop = 1;
	    k_set_loop(TRUE);
	}
    }

    bzero(&sdst, sizeof(sdst));
    sdst.sin_family = AF_INET;
    sdst.sin_len = sizeof(sdst);
    sdst.sin_addr.s_addr = dst;
    if (sendto(igmp_socket, send_buf, ntohs(ip->ip_len), 0,
			(struct sockaddr *)&sdst, sizeof(sdst)) < 0) {
	if (errno == ENETDOWN)
	    check_vif_state();
	else
	    logit(igmp_log_level(type, code), errno,
		"sendto to %s on %s",
		inet_fmt(dst, s1), inet_fmt(src, s2));
    }

    if (setloop)
	    k_set_loop(FALSE);

    logit(LOG_DEBUG, 0, "SENT %s from %-15s to %s",
	packet_kind(type, code), inet_fmt(src, s1), inet_fmt(dst, s2));
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $NetBSD: igmp.c,v 1.5 1995/12/10 10:07:01 mycroft Exp $ */
2
3			/*
4			* The mrouted program is covered by the license in the accompanying file
5			* named "LICENSE". Use of the mrouted program represents acceptance of
6			* the terms and conditions listed in that file.
7			*
8			* The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
9			* Leland Stanford Junior University.
10			*/
11
12
13			#include "defs.h"
14
15
16			/*
17			* Exported variables.
18			*/
19			char recv_buf; / input packet buffer */
20			char send_buf; / output packet buffer */
21			int igmp_socket; /* socket for all network I/O */
22			u_int32_t allhosts_group; /* All hosts addr in net order */
23			u_int32_t allrtrs_group; /* All-Routers " in net order */
24			u_int32_t dvmrp_group; /* DVMRP grp addr in net order */
25			u_int32_t dvmrp_genid; /* IGMP generation id */
26
27			/*
28			* Local function definitions.
29			*/
30			/* u_char promoted to u_int */
31			static char * packet_kind(u_int type, u_int code);
32			static int igmp_log_level(u_int type, u_int code);
33
34			/*
35			* Open and initialize the igmp socket, and fill in the non-changing
36			* IP header fields in the output packet buffer.
37			*/
38			void
39			init_igmp(void)
40			{
41			struct ip *ip;
42
43			recv_buf = malloc(RECV_BUF_SIZE);
44			send_buf = malloc(RECV_BUF_SIZE);
45
46			if ((igmp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP)) < 0)
47			logit(LOG_ERR, errno, "IGMP socket");
48
49			k_hdr_include(TRUE); /* include IP header when sending */
50			k_set_rcvbuf(481024); / lots of input buffering */
51			k_set_ttl(1); /* restrict multicasts to one hop */
52			k_set_loop(FALSE); /* disable multicast loopback */
53
54			ip = (struct ip *)send_buf;
55			ip->ip_hl = sizeof(struct ip) >> 2;
56			ip->ip_v = IPVERSION;
57			ip->ip_tos = 0;
58			ip->ip_off = htons(0);
59			ip->ip_p = IPPROTO_IGMP;
60			ip->ip_ttl = MAXTTL; /* applies to unicasts only */
61
62			allhosts_group = htonl(INADDR_ALLHOSTS_GROUP);
63			dvmrp_group = htonl(INADDR_DVMRP_GROUP);
64			allrtrs_group = htonl(INADDR_ALLRTRS_GROUP);
65			}
66
67			#define PIM_QUERY 0
68			#define PIM_REGISTER 1
69			#define PIM_REGISTER_STOP 2
70			#define PIM_JOIN_PRUNE 3
71			#define PIM_RP_REACHABLE 4
72			#define PIM_ASSERT 5
73			#define PIM_GRAFT 6
74			#define PIM_GRAFT_ACK 7
75
76			static char *
77			packet_kind(u_int type, u_int code)
78			{
79			switch (type) {
80			case IGMP_HOST_MEMBERSHIP_QUERY: return "membership query ";
81			case IGMP_v1_HOST_MEMBERSHIP_REPORT: return "v1 member report ";
82			case IGMP_v2_HOST_MEMBERSHIP_REPORT: return "v2 member report ";
83			case IGMP_HOST_LEAVE_MESSAGE: return "leave message ";
84			case IGMP_DVMRP:
85			switch (code) {
86			case DVMRP_PROBE: return "neighbor probe ";
87			case DVMRP_REPORT: return "route report ";
88			case DVMRP_ASK_NEIGHBORS: return "neighbor request ";
89			case DVMRP_NEIGHBORS: return "neighbor list ";
90			case DVMRP_ASK_NEIGHBORS2: return "neighbor request 2";
91			case DVMRP_NEIGHBORS2: return "neighbor list 2 ";
92			case DVMRP_PRUNE: return "prune message ";
93			case DVMRP_GRAFT: return "graft message ";
94			case DVMRP_GRAFT_ACK: return "graft message ack ";
95			case DVMRP_INFO_REQUEST: return "info request ";
96			case DVMRP_INFO_REPLY: return "info reply ";
97			default: return "unknown DVMRP msg ";
98			}
99			case IGMP_PIM:
100			switch (code) {
101			case PIM_QUERY: return "PIM Router-Query ";
102			case PIM_REGISTER: return "PIM Register ";
103			case PIM_REGISTER_STOP: return "PIM Register-Stop ";
104			case PIM_JOIN_PRUNE: return "PIM Join/Prune ";
105			case PIM_RP_REACHABLE: return "PIM RP-Reachable ";
106			case PIM_ASSERT: return "PIM Assert ";
107			case PIM_GRAFT: return "PIM Graft ";
108			case PIM_GRAFT_ACK: return "PIM Graft-Ack ";
109			default: return "unknown PIM msg ";
110			}
111			case IGMP_MTRACE_QUERY: return "IGMP trace query ";
112			case IGMP_MTRACE_REPLY: return "IGMP trace reply ";
113			default: return "unknown IGMP msg ";
114			}
115			}
116
117			/*
118			* Process a newly received IGMP packet that is sitting in the input
119			* packet buffer.
120			*/
121			void
122			accept_igmp(int recvlen)
123			{
124			u_int32_t src, dst, group;
125			struct ip *ip;
126			struct igmp *igmp;
127			int ipdatalen, iphdrlen, igmpdatalen;
128
129			if (recvlen < sizeof(struct ip)) {
130			logit(LOG_WARNING, 0,
131			"received packet too short (%u bytes) for IP header", recvlen);
132			return;
133			}
134
135			ip = (struct ip *)recv_buf;
136			src = ip->ip_src.s_addr;
137			dst = ip->ip_dst.s_addr;
138
139			/*
140			* this is most likely a message from the kernel indicating that
141			* a new src grp pair message has arrived and so, it would be
142			* necessary to install a route into the kernel for this.
143			*/
144			if (ip->ip_p == 0) {
145			if (src == 0 \|\| dst == 0)
146			logit(LOG_WARNING, 0, "kernel request not accurate");
147			else
148			add_table_entry(src, dst);
149			return;
150			}
151
152			iphdrlen = ip->ip_hl << 2;
153			ipdatalen = ntohs(ip->ip_len) - iphdrlen;
154			if (iphdrlen + ipdatalen != recvlen) {
155			logit(LOG_WARNING, 0,
156			"received packet from %s shorter (%u bytes) than hdr+data length (%u+%u)",
157			inet_fmt(src, s1), recvlen, iphdrlen, ipdatalen);
158			return;
159			}
160
161			igmp = (struct igmp *)(recv_buf + iphdrlen);
162			group = igmp->igmp_group.s_addr;
163			igmpdatalen = ipdatalen - IGMP_MINLEN;
164			if (igmpdatalen < 0) {
165			logit(LOG_WARNING, 0,
166			"received IP data field too short (%u bytes) for IGMP, from %s",
167			ipdatalen, inet_fmt(src, s1));
168			return;
169			}
170
171			logit(LOG_DEBUG, 0, "RECV %s from %-15s to %s",
172			packet_kind(igmp->igmp_type, igmp->igmp_code),
173			inet_fmt(src, s1), inet_fmt(dst, s2));
174
175			switch (igmp->igmp_type) {
176
177			case IGMP_HOST_MEMBERSHIP_QUERY:
178			accept_membership_query(src, dst, group, igmp->igmp_code);
179			return;
180
181			case IGMP_v1_HOST_MEMBERSHIP_REPORT:
182			case IGMP_v2_HOST_MEMBERSHIP_REPORT:
183			accept_group_report(src, dst, group, igmp->igmp_type);
184			return;
185
186			case IGMP_HOST_LEAVE_MESSAGE:
187			accept_leave_message(src, dst, group);
188			return;
189
190			case IGMP_DVMRP:
191			group = ntohl(group);
192
193			switch (igmp->igmp_code) {
194			case DVMRP_PROBE:
195			accept_probe(src, dst,
196			(char *)(igmp+1), igmpdatalen, group);
197			return;
198
199			case DVMRP_REPORT:
200			accept_report(src, dst,
201			(char *)(igmp+1), igmpdatalen, group);
202			return;
203
204			case DVMRP_ASK_NEIGHBORS:
205			accept_neighbor_request(src, dst);
206			return;
207
208			case DVMRP_ASK_NEIGHBORS2:
209			accept_neighbor_request2(src, dst);
210			return;
211
212			case DVMRP_NEIGHBORS:
213			accept_neighbors(src, dst, (u_char *)(igmp+1), igmpdatalen,
214			group);
215			return;
216
217			case DVMRP_NEIGHBORS2:
218			accept_neighbors2(src, dst, (u_char *)(igmp+1), igmpdatalen,
219			group);
220			return;
221
222			case DVMRP_PRUNE:
223			accept_prune(src, dst, (char *)(igmp+1), igmpdatalen);
224			return;
225
226			case DVMRP_GRAFT:
227			accept_graft(src, dst, (char *)(igmp+1), igmpdatalen);
228			return;
229
230			case DVMRP_GRAFT_ACK:
231			accept_g_ack(src, dst, (char *)(igmp+1), igmpdatalen);
232			return;
233
234			case DVMRP_INFO_REQUEST:
235			accept_info_request(src, dst, (char *)(igmp+1),
236			igmpdatalen);
237			return;
238
239			case DVMRP_INFO_REPLY:
240			accept_info_reply(src, dst, (char *)(igmp+1), igmpdatalen);
241			return;
242
243			default:
244			logit(LOG_INFO, 0,
245			"ignoring unknown DVMRP message code %u from %s to %s",
246			igmp->igmp_code, inet_fmt(src, s1),
247			inet_fmt(dst, s2));
248			return;
249			}
250
251			case IGMP_PIM:
252			return;
253
254			case IGMP_MTRACE_REPLY:
255			return;
256
257			case IGMP_MTRACE_QUERY:
258			accept_mtrace(src, dst, group, (char *)(igmp+1),
259			igmp->igmp_code, igmpdatalen);
260			return;
261
262			default:
263			logit(LOG_INFO, 0,
264			"ignoring unknown IGMP message type %x from %s to %s",
265			igmp->igmp_type, inet_fmt(src, s1),
266			inet_fmt(dst, s2));
267			return;
268			}
269			}
270
271			/*
272			* Some IGMP messages are more important than others. This routine
273			* determines the logging level at which to log a send error (often
274			* "No route to host"). This is important when there is asymmetric
275			* reachability and someone is trying to, i.e., mrinfo me periodically.
276			*/
277			static int
278			igmp_log_level(u_int type, u_int code)
279			{
280			switch (type) {
281			case IGMP_MTRACE_REPLY:
282			return LOG_INFO;
283
284			case IGMP_DVMRP:
285			switch (code) {
286			case DVMRP_NEIGHBORS:
287			case DVMRP_NEIGHBORS2:
288			return LOG_INFO;
289			}
290			}
291			return LOG_WARNING;
292			}
293
294			/*
295			* Construct an IGMP message in the output packet buffer. The caller may
296			* have already placed data in that buffer, of length 'datalen'. Then send
297			* the message from the interface with IP address 'src' to destination 'dst'.
298			*/
299			void
300			send_igmp(u_int32_t src, u_int32_t dst, int type, int code,
301			u_int32_t group, int datalen)
302			{
303			struct sockaddr_in sdst;
304			struct ip *ip;
305			struct igmp *igmp;
306			int setloop = 0;
307
308			ip = (struct ip *)send_buf;
309			ip->ip_src.s_addr = src;
310			ip->ip_dst.s_addr = dst;
311			ip->ip_len = htons(MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen);
312
313			igmp = (struct igmp *)(send_buf + MIN_IP_HEADER_LEN);
314			igmp->igmp_type = type;
315			igmp->igmp_code = code;
316			igmp->igmp_group.s_addr = group;
317			igmp->igmp_cksum = 0;
318			igmp->igmp_cksum = inet_cksum((u_int16_t *)igmp,
319			IGMP_MINLEN + datalen);
320
321			if (IN_MULTICAST(ntohl(dst))) {
322			k_set_if(src);
323			if (type != IGMP_DVMRP) {
324			setloop = 1;
325			k_set_loop(TRUE);
326			}
327			}
328
329			bzero(&sdst, sizeof(sdst));
330			sdst.sin_family = AF_INET;
331			sdst.sin_len = sizeof(sdst);
332			sdst.sin_addr.s_addr = dst;
333			if (sendto(igmp_socket, send_buf, ntohs(ip->ip_len), 0,
334			(struct sockaddr *)&sdst, sizeof(sdst)) < 0) {
335			if (errno == ENETDOWN)
336			check_vif_state();
337			else
338			logit(igmp_log_level(type, code), errno,
339			"sendto to %s on %s",
340			inet_fmt(dst, s1), inet_fmt(src, s2));
341			}
342
343			if (setloop)
344			k_set_loop(FALSE);
345
346			logit(LOG_DEBUG, 0, "SENT %s from %-15s to %s",
347			packet_kind(type, code), inet_fmt(src, s1), inet_fmt(dst, s2));
348			}