2 * The mrouted program is covered by the license in the accompanying file
3 * named "LICENSE". Use of the mrouted program represents acceptance of
4 * the terms and conditions listed in that file.
6 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
7 * Leland Stanford Junior University.
10 * igmp.c,v 3.8.4.19 1998/01/06 01:57:43 fenner Exp
14 static const char rcsid[] =
15 "$FreeBSD: src/usr.sbin/mrouted/igmp.c,v 1.16 1999/08/28 01:17:04 peter Exp $";
23 char *recv_buf; /* input packet buffer */
24 char *send_buf; /* output packet buffer */
25 int igmp_socket; /* socket for all network I/O */
26 u_int32 allhosts_group; /* All hosts addr in net order */
27 u_int32 allrtrs_group; /* All-Routers " in net order */
28 u_int32 dvmrp_group; /* DVMRP grp addr in net order */
29 u_int32 dvmrp_genid; /* IGMP generation id */
32 * Local function definitions.
34 /* u_char promoted to u_int */
35 static int igmp_log_level __P((u_int type, u_int code));
38 * Open and initialize the igmp socket, and fill in the non-changing
39 * IP header fields in the output packet buffer.
46 recv_buf = malloc(RECV_BUF_SIZE);
47 send_buf = malloc(RECV_BUF_SIZE);
49 if ((igmp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP)) < 0)
50 log(LOG_ERR, errno, "IGMP socket");
52 k_hdr_include(TRUE); /* include IP header when sending */
53 k_set_rcvbuf(256*1024,48*1024); /* lots of input buffering */
54 k_set_ttl(1); /* restrict multicasts to one hop */
55 k_set_loop(FALSE); /* disable multicast loopback */
57 ip = (struct ip *)send_buf;
58 bzero(ip, sizeof(struct ip));
60 * Fields zeroed that aren't filled in later:
61 * - IP ID (let the kernel fill it in)
62 * - Offset (we don't send fragments)
63 * - Checksum (let the kernel fill it in)
66 ip->ip_hl = sizeof(struct ip) >> 2;
67 ip->ip_tos = 0xc0; /* Internet Control */
68 ip->ip_ttl = MAXTTL; /* applies to unicasts only */
69 ip->ip_p = IPPROTO_IGMP;
71 allhosts_group = htonl(INADDR_ALLHOSTS_GROUP);
72 dvmrp_group = htonl(INADDR_DVMRP_GROUP);
73 allrtrs_group = htonl(INADDR_ALLRTRS_GROUP);
77 #define PIM_REGISTER 1
78 #define PIM_REGISTER_STOP 2
79 #define PIM_JOIN_PRUNE 3
80 #define PIM_RP_REACHABLE 4
83 #define PIM_GRAFT_ACK 7
86 igmp_packet_kind(type, code)
89 static char unknown[20];
92 case IGMP_MEMBERSHIP_QUERY: return "membership query ";
93 case IGMP_V1_MEMBERSHIP_REPORT: return "V1 member report ";
94 case IGMP_V2_MEMBERSHIP_REPORT: return "V2 member report ";
95 case IGMP_V2_LEAVE_GROUP: return "leave message ";
98 case DVMRP_PROBE: return "neighbor probe ";
99 case DVMRP_REPORT: return "route report ";
100 case DVMRP_ASK_NEIGHBORS: return "neighbor request ";
101 case DVMRP_NEIGHBORS: return "neighbor list ";
102 case DVMRP_ASK_NEIGHBORS2: return "neighbor request 2";
103 case DVMRP_NEIGHBORS2: return "neighbor list 2 ";
104 case DVMRP_PRUNE: return "prune message ";
105 case DVMRP_GRAFT: return "graft message ";
106 case DVMRP_GRAFT_ACK: return "graft message ack ";
107 case DVMRP_INFO_REQUEST: return "info request ";
108 case DVMRP_INFO_REPLY: return "info reply ";
110 sprintf(unknown, "unknown DVMRP %3d ", code);
115 case PIM_QUERY: return "PIM Router-Query ";
116 case PIM_REGISTER: return "PIM Register ";
117 case PIM_REGISTER_STOP: return "PIM Register-Stop ";
118 case PIM_JOIN_PRUNE: return "PIM Join/Prune ";
119 case PIM_RP_REACHABLE: return "PIM RP-Reachable ";
120 case PIM_ASSERT: return "PIM Assert ";
121 case PIM_GRAFT: return "PIM Graft ";
122 case PIM_GRAFT_ACK: return "PIM Graft-Ack ";
124 sprintf(unknown, "unknown PIM msg%3d", code);
127 case IGMP_MTRACE: return "IGMP trace query ";
128 case IGMP_MTRACE_RESP: return "IGMP trace reply ";
130 sprintf(unknown, "unk: 0x%02x/0x%02x ", type, code);
136 igmp_debug_kind(type, code)
140 case IGMP_MEMBERSHIP_QUERY: return DEBUG_IGMP;
141 case IGMP_V1_MEMBERSHIP_REPORT: return DEBUG_IGMP;
142 case IGMP_V2_MEMBERSHIP_REPORT: return DEBUG_IGMP;
143 case IGMP_V2_LEAVE_GROUP: return DEBUG_IGMP;
146 case DVMRP_PROBE: return DEBUG_PEER;
147 case DVMRP_REPORT: return DEBUG_ROUTE;
148 case DVMRP_ASK_NEIGHBORS: return 0;
149 case DVMRP_NEIGHBORS: return 0;
150 case DVMRP_ASK_NEIGHBORS2: return 0;
151 case DVMRP_NEIGHBORS2: return 0;
152 case DVMRP_PRUNE: return DEBUG_PRUNE;
153 case DVMRP_GRAFT: return DEBUG_PRUNE;
154 case DVMRP_GRAFT_ACK: return DEBUG_PRUNE;
155 case DVMRP_INFO_REQUEST: return 0;
156 case DVMRP_INFO_REPLY: return 0;
161 case PIM_QUERY: return 0;
162 case PIM_REGISTER: return 0;
163 case PIM_REGISTER_STOP: return 0;
164 case PIM_JOIN_PRUNE: return 0;
165 case PIM_RP_REACHABLE: return 0;
166 case PIM_ASSERT: return 0;
167 case PIM_GRAFT: return 0;
168 case PIM_GRAFT_ACK: return 0;
171 case IGMP_MTRACE: return DEBUG_TRACE;
172 case IGMP_MTRACE_RESP: return DEBUG_TRACE;
173 default: return DEBUG_IGMP;
178 * Process a newly received IGMP packet that is sitting in the input
185 register u_int32 src, dst, group;
188 int ipdatalen, iphdrlen, igmpdatalen;
190 if (recvlen < sizeof(struct ip)) {
192 "received packet too short (%u bytes) for IP header", recvlen);
196 ip = (struct ip *)recv_buf;
197 src = ip->ip_src.s_addr;
198 dst = ip->ip_dst.s_addr;
201 * this is most likely a message from the kernel indicating that
202 * a new src grp pair message has arrived and so, it would be
203 * necessary to install a route into the kernel for this.
206 if (src == 0 || dst == 0)
207 log(LOG_WARNING, 0, "kernel request not accurate");
209 add_table_entry(src, dst);
213 iphdrlen = ip->ip_hl << 2;
214 #ifdef RAW_INPUT_IS_RAW
215 ipdatalen = ntohs(ip->ip_len) - iphdrlen;
217 ipdatalen = ip->ip_len;
219 if (iphdrlen + ipdatalen != recvlen) {
221 "received packet from %s shorter (%u bytes) than hdr+data length (%u+%u)",
222 inet_fmt(src, s1), recvlen, iphdrlen, ipdatalen);
226 igmp = (struct igmp *)(recv_buf + iphdrlen);
227 group = igmp->igmp_group.s_addr;
228 igmpdatalen = ipdatalen - IGMP_MINLEN;
229 if (igmpdatalen < 0) {
231 "received IP data field too short (%u bytes) for IGMP, from %s",
232 ipdatalen, inet_fmt(src, s1));
236 IF_DEBUG(DEBUG_PKT|igmp_debug_kind(igmp->igmp_type, igmp->igmp_code))
237 log(LOG_DEBUG, 0, "RECV %s from %-15s to %s",
238 igmp_packet_kind(igmp->igmp_type, igmp->igmp_code),
239 inet_fmt(src, s1), inet_fmt(dst, s2));
241 switch (igmp->igmp_type) {
243 case IGMP_MEMBERSHIP_QUERY:
244 accept_membership_query(src, dst, group, igmp->igmp_code);
247 case IGMP_V1_MEMBERSHIP_REPORT:
248 case IGMP_V2_MEMBERSHIP_REPORT:
249 accept_group_report(src, dst, group, igmp->igmp_type);
252 case IGMP_V2_LEAVE_GROUP:
253 accept_leave_message(src, dst, group);
257 group = ntohl(group);
259 switch (igmp->igmp_code) {
261 accept_probe(src, dst,
262 (char *)(igmp+1), igmpdatalen, group);
266 accept_report(src, dst,
267 (char *)(igmp+1), igmpdatalen, group);
270 case DVMRP_ASK_NEIGHBORS:
271 accept_neighbor_request(src, dst);
274 case DVMRP_ASK_NEIGHBORS2:
275 accept_neighbor_request2(src, dst);
278 case DVMRP_NEIGHBORS:
279 accept_neighbors(src, dst, (u_char *)(igmp+1), igmpdatalen,
283 case DVMRP_NEIGHBORS2:
284 accept_neighbors2(src, dst, (u_char *)(igmp+1), igmpdatalen,
289 accept_prune(src, dst, (char *)(igmp+1), igmpdatalen);
293 accept_graft(src, dst, (char *)(igmp+1), igmpdatalen);
296 case DVMRP_GRAFT_ACK:
297 accept_g_ack(src, dst, (char *)(igmp+1), igmpdatalen);
300 case DVMRP_INFO_REQUEST:
301 accept_info_request(src, dst, (char *)(igmp+1),
305 case DVMRP_INFO_REPLY:
306 accept_info_reply(src, dst, (char *)(igmp+1), igmpdatalen);
311 "ignoring unknown DVMRP message code %u from %s to %s",
312 igmp->igmp_code, inet_fmt(src, s1),
320 case IGMP_MTRACE_RESP:
324 accept_mtrace(src, dst, group, (char *)(igmp+1),
325 igmp->igmp_code, igmpdatalen);
330 "ignoring unknown IGMP message type %x from %s to %s",
331 igmp->igmp_type, inet_fmt(src, s1),
338 * Some IGMP messages are more important than others. This routine
339 * determines the logging level at which to log a send error (often
340 * "No route to host"). This is important when there is asymmetric
341 * reachability and someone is trying to, i.e., mrinfo me periodically.
344 igmp_log_level(type, code)
348 case IGMP_MTRACE_RESP:
353 case DVMRP_NEIGHBORS:
354 case DVMRP_NEIGHBORS2:
362 * Construct an IGMP message in the output packet buffer. The caller may
363 * have already placed data in that buffer, of length 'datalen'.
366 build_igmp(src, dst, type, code, group, datalen)
376 ip = (struct ip *)send_buf;
377 ip->ip_src.s_addr = src;
378 ip->ip_dst.s_addr = dst;
379 ip->ip_len = MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen;
380 #ifdef RAW_OUTPUT_IS_RAW
381 ip->ip_len = htons(ip->ip_len);
383 if (IN_MULTICAST(ntohl(dst))) {
389 igmp = (struct igmp *)(send_buf + MIN_IP_HEADER_LEN);
390 igmp->igmp_type = type;
391 igmp->igmp_code = code;
392 igmp->igmp_group.s_addr = group;
393 igmp->igmp_cksum = 0;
394 igmp->igmp_cksum = inet_cksum((u_short *)igmp,
395 IGMP_MINLEN + datalen);
399 * Call build_igmp() to build an IGMP message in the output packet buffer.
400 * Then send the message from the interface with IP address 'src' to
404 send_igmp(src, dst, type, code, group, datalen)
410 struct sockaddr_in sdst;
413 build_igmp(src, dst, type, code, group, datalen);
415 if (IN_MULTICAST(ntohl(dst))) {
417 if (type != IGMP_DVMRP || dst == allhosts_group) {
423 bzero(&sdst, sizeof(sdst));
424 sdst.sin_family = AF_INET;
426 sdst.sin_len = sizeof(sdst);
428 sdst.sin_addr.s_addr = dst;
429 if (sendto(igmp_socket, send_buf,
430 MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen, 0,
431 (struct sockaddr *)&sdst, sizeof(sdst)) < 0) {
432 if (errno == ENETDOWN)
435 log(igmp_log_level(type, code), errno,
436 "sendto to %s on %s",
437 inet_fmt(dst, s1), inet_fmt(src, s2));
443 IF_DEBUG(DEBUG_PKT|igmp_debug_kind(type, code))
444 log(LOG_DEBUG, 0, "SENT %s from %-15s to %s",
445 igmp_packet_kind(type, code), src == INADDR_ANY ? "INADDR_ANY" :
446 inet_fmt(src, s1), inet_fmt(dst, s2));