1 /*
2 PIM for Quagga
3 Copyright (C) 2008 Everton da Silva Marques
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING; if not, write to the
17 Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
18 MA 02110-1301 USA
19
20 $QuaggaId: $Format:%an, %ai, %h$ $
21 */
22
23 #include <zebra.h>
24
25 #include "if.h"
26 #include "log.h"
27 #include "memory.h"
28
29 #include "pim_ssmpingd.h"
30 #include "pim_time.h"
31 #include "pim_sock.h"
32 #include "pim_str.h"
33 #include "pimd.h"
34
35 static const char * const PIM_SSMPINGD_REPLY_GROUP = "232.43.211.234";
36
37 enum {
38 PIM_SSMPINGD_REQUEST = 'Q',
39 PIM_SSMPINGD_REPLY = 'A'
40 };
41
42 static void ssmpingd_read_on(struct ssmpingd_sock *ss);
43
pim_ssmpingd_init()44 void pim_ssmpingd_init()
45 {
46 int result;
47
48 zassert(!qpim_ssmpingd_list);
49
50 result = inet_pton(AF_INET, PIM_SSMPINGD_REPLY_GROUP, &qpim_ssmpingd_group_addr);
51
52 zassert(result > 0);
53 }
54
pim_ssmpingd_destroy()55 void pim_ssmpingd_destroy()
56 {
57 if (qpim_ssmpingd_list) {
58 list_free(qpim_ssmpingd_list);
59 qpim_ssmpingd_list = 0;
60 }
61 }
62
ssmpingd_find(struct in_addr source_addr)63 static struct ssmpingd_sock *ssmpingd_find(struct in_addr source_addr)
64 {
65 struct listnode *node;
66 struct ssmpingd_sock *ss;
67
68 if (!qpim_ssmpingd_list)
69 return 0;
70
71 for (ALL_LIST_ELEMENTS_RO(qpim_ssmpingd_list, node, ss))
72 if (source_addr.s_addr == ss->source_addr.s_addr)
73 return ss;
74
75 return 0;
76 }
77
ssmpingd_free(struct ssmpingd_sock * ss)78 static void ssmpingd_free(struct ssmpingd_sock *ss)
79 {
80 XFREE(MTYPE_PIM_SSMPINGD, ss);
81 }
82
ssmpingd_socket(struct in_addr addr,int port,int mttl)83 static int ssmpingd_socket(struct in_addr addr, int port, int mttl)
84 {
85 struct sockaddr_in sockaddr;
86 int fd;
87
88 fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
89 if (fd < 0) {
90 zlog_err("%s: could not create socket: errno=%d: %s",
91 __PRETTY_FUNCTION__, errno, safe_strerror(errno));
92 return -1;
93 }
94
95 sockaddr.sin_family = AF_INET;
96 sockaddr.sin_addr = addr;
97 sockaddr.sin_port = htons(port);
98
99 if (bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr))) {
100 char addr_str[100];
101 pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
102 zlog_warn("%s: bind(fd=%d,addr=%s,port=%d,len=%zu) failure: errno=%d: %s",
103 __PRETTY_FUNCTION__,
104 fd, addr_str, port, sizeof(sockaddr),
105 errno, safe_strerror(errno));
106 close(fd);
107 return -1;
108 }
109
110 /* Needed to obtain destination address from recvmsg() */
111 {
112 #if defined(HAVE_IP_PKTINFO)
113 /* Linux and Solaris IP_PKTINFO */
114 int opt = 1;
115 if (setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &opt, sizeof(opt))) {
116 zlog_warn("%s: could not set IP_PKTINFO on socket fd=%d: errno=%d: %s",
117 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
118 }
119 #elif defined(HAVE_IP_RECVDSTADDR)
120 /* BSD IP_RECVDSTADDR */
121 int opt = 1;
122 if (setsockopt(fd, IPPROTO_IP, IP_RECVDSTADDR, &opt, sizeof(opt))) {
123 zlog_warn("%s: could not set IP_RECVDSTADDR on socket fd=%d: errno=%d: %s",
124 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
125 }
126 #else
127 zlog_err("%s %s: missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
128 __FILE__, __PRETTY_FUNCTION__);
129 close(fd);
130 return -1;
131 #endif
132 }
133
134 {
135 int reuse = 1;
136 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
137 (void *) &reuse, sizeof(reuse))) {
138 zlog_warn("%s: could not set Reuse Address Option on socket fd=%d: errno=%d: %s",
139 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
140 close(fd);
141 return -1;
142 }
143 }
144
145 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL,
146 (void *) &mttl, sizeof(mttl))) {
147 zlog_warn("%s: could not set multicast TTL=%d on socket fd=%d: errno=%d: %s",
148 __PRETTY_FUNCTION__, mttl, fd, errno, safe_strerror(errno));
149 close(fd);
150 return -1;
151 }
152
153 {
154 int loop = 0;
155 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
156 (void *) &loop, sizeof(loop))) {
157 zlog_warn("%s: could not %s Multicast Loopback Option on socket fd=%d: errno=%d: %s",
158 __PRETTY_FUNCTION__,
159 loop ? "enable" : "disable",
160 fd, errno, safe_strerror(errno));
161 close(fd);
162 return PIM_SOCK_ERR_LOOP;
163 }
164 }
165
166 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
167 (void *) &addr, sizeof(addr))) {
168 zlog_warn("%s: could not set Outgoing Interface Option on socket fd=%d: errno=%d: %s",
169 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
170 close(fd);
171 return -1;
172 }
173
174 {
175 long flags;
176
177 flags = fcntl(fd, F_GETFL, 0);
178 if (flags < 0) {
179 zlog_warn("%s: could not get fcntl(F_GETFL,O_NONBLOCK) on socket fd=%d: errno=%d: %s",
180 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
181 close(fd);
182 return -1;
183 }
184
185 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK)) {
186 zlog_warn("%s: could not set fcntl(F_SETFL,O_NONBLOCK) on socket fd=%d: errno=%d: %s",
187 __PRETTY_FUNCTION__, fd, errno, safe_strerror(errno));
188 close(fd);
189 return -1;
190 }
191 }
192
193 return fd;
194 }
195
ssmpingd_delete(struct ssmpingd_sock * ss)196 static void ssmpingd_delete(struct ssmpingd_sock *ss)
197 {
198 zassert(ss);
199 zassert(qpim_ssmpingd_list);
200
201 THREAD_OFF(ss->t_sock_read);
202
203 if (close(ss->sock_fd)) {
204 int e = errno;
205 char source_str[100];
206 pim_inet4_dump("<src?>", ss->source_addr, source_str, sizeof(source_str));
207 zlog_warn("%s: failure closing ssmpingd sock_fd=%d for source %s: errno=%d: %s",
208 __PRETTY_FUNCTION__,
209 ss->sock_fd, source_str, e, safe_strerror(e));
210 /* warning only */
211 }
212
213 listnode_delete(qpim_ssmpingd_list, ss);
214 ssmpingd_free(ss);
215 }
216
ssmpingd_sendto(struct ssmpingd_sock * ss,const uint8_t * buf,int len,struct sockaddr_in to)217 static void ssmpingd_sendto(struct ssmpingd_sock *ss,
218 const uint8_t *buf,
219 int len,
220 struct sockaddr_in to)
221 {
222 socklen_t tolen = sizeof(to);
223 int sent;
224
225 sent = sendto(ss->sock_fd, buf, len, MSG_DONTWAIT,
226 (struct sockaddr *)&to, tolen);
227 if (sent != len) {
228 int e = errno;
229 char to_str[100];
230 pim_inet4_dump("<to?>", to.sin_addr, to_str, sizeof(to_str));
231 if (sent < 0) {
232 zlog_warn("%s: sendto() failure to %s,%d: fd=%d len=%d: errno=%d: %s",
233 __PRETTY_FUNCTION__,
234 to_str, ntohs(to.sin_port), ss->sock_fd, len,
235 e, safe_strerror(e));
236 }
237 else {
238 zlog_warn("%s: sendto() partial to %s,%d: fd=%d len=%d: sent=%d",
239 __PRETTY_FUNCTION__,
240 to_str, ntohs(to.sin_port), ss->sock_fd,
241 len, sent);
242 }
243 }
244 }
245
ssmpingd_read_msg(struct ssmpingd_sock * ss)246 static int ssmpingd_read_msg(struct ssmpingd_sock *ss)
247 {
248 struct interface *ifp;
249 struct sockaddr_in from;
250 struct sockaddr_in to;
251 socklen_t fromlen = sizeof(from);
252 socklen_t tolen = sizeof(to);
253 ifindex_t ifindex = -1;
254 uint8_t buf[1000];
255 int len;
256
257 ++ss->requests;
258
259 len = pim_socket_recvfromto(ss->sock_fd, buf, sizeof(buf),
260 &from, &fromlen,
261 &to, &tolen,
262 &ifindex);
263 if (len < 0) {
264 char source_str[100];
265 pim_inet4_dump("<src?>", ss->source_addr, source_str, sizeof(source_str));
266 zlog_warn("%s: failure receiving ssmping for source %s on fd=%d: errno=%d: %s",
267 __PRETTY_FUNCTION__, source_str, ss->sock_fd, errno, safe_strerror(errno));
268 return -1;
269 }
270
271 ifp = if_lookup_by_index(ifindex);
272
273 if (buf[0] != PIM_SSMPINGD_REQUEST) {
274 char source_str[100];
275 char from_str[100];
276 char to_str[100];
277 pim_inet4_dump("<src?>", ss->source_addr, source_str, sizeof(source_str));
278 pim_inet4_dump("<from?>", from.sin_addr, from_str, sizeof(from_str));
279 pim_inet4_dump("<to?>", to.sin_addr, to_str, sizeof(to_str));
280 zlog_warn("%s: bad ssmping type=%d from %s,%d to %s,%d on interface %s ifindex=%d fd=%d src=%s",
281 __PRETTY_FUNCTION__,
282 buf[0],
283 from_str, ntohs(from.sin_port),
284 to_str, ntohs(to.sin_port),
285 ifp ? ifp->name : "<iface?>",
286 ifindex, ss->sock_fd,
287 source_str);
288 return 0;
289 }
290
291 if (PIM_DEBUG_SSMPINGD) {
292 char source_str[100];
293 char from_str[100];
294 char to_str[100];
295 pim_inet4_dump("<src?>", ss->source_addr, source_str, sizeof(source_str));
296 pim_inet4_dump("<from?>", from.sin_addr, from_str, sizeof(from_str));
297 pim_inet4_dump("<to?>", to.sin_addr, to_str, sizeof(to_str));
298 zlog_debug("%s: recv ssmping from %s,%d to %s,%d on interface %s ifindex=%d fd=%d src=%s",
299 __PRETTY_FUNCTION__,
300 from_str, ntohs(from.sin_port),
301 to_str, ntohs(to.sin_port),
302 ifp ? ifp->name : "<iface?>",
303 ifindex, ss->sock_fd,
304 source_str);
305 }
306
307 buf[0] = PIM_SSMPINGD_REPLY;
308
309 /* unicast reply */
310 ssmpingd_sendto(ss, buf, len, from);
311
312 /* multicast reply */
313 from.sin_addr = qpim_ssmpingd_group_addr;
314 ssmpingd_sendto(ss, buf, len, from);
315
316 return 0;
317 }
318
ssmpingd_sock_read(struct thread * t)319 static int ssmpingd_sock_read(struct thread *t)
320 {
321 struct ssmpingd_sock *ss;
322 int sock_fd;
323 int result;
324
325 zassert(t);
326
327 ss = THREAD_ARG(t);
328 zassert(ss);
329
330 sock_fd = THREAD_FD(t);
331 zassert(sock_fd == ss->sock_fd);
332
333 result = ssmpingd_read_msg(ss);
334
335 /* Keep reading */
336 ss->t_sock_read = 0;
337 ssmpingd_read_on(ss);
338
339 return result;
340 }
341
ssmpingd_read_on(struct ssmpingd_sock * ss)342 static void ssmpingd_read_on(struct ssmpingd_sock *ss)
343 {
344 zassert(!ss->t_sock_read);
345 THREAD_READ_ON(master, ss->t_sock_read,
346 ssmpingd_sock_read, ss, ss->sock_fd);
347 }
348
ssmpingd_new(struct in_addr source_addr)349 static struct ssmpingd_sock *ssmpingd_new(struct in_addr source_addr)
350 {
351 struct ssmpingd_sock *ss;
352 int sock_fd;
353
354 if (!qpim_ssmpingd_list) {
355 qpim_ssmpingd_list = list_new();
356 if (!qpim_ssmpingd_list) {
357 zlog_err("%s %s: failure: qpim_ssmpingd_list=list_new()",
358 __FILE__, __PRETTY_FUNCTION__);
359 return 0;
360 }
361 qpim_ssmpingd_list->del = (void (*)(void *)) ssmpingd_free;
362 }
363
364 sock_fd = ssmpingd_socket(source_addr, /* port: */ 4321, /* mTTL: */ 64);
365 if (sock_fd < 0) {
366 char source_str[100];
367 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
368 zlog_warn("%s: ssmpingd_socket() failure for source %s",
369 __PRETTY_FUNCTION__, source_str);
370 return 0;
371 }
372
373 ss = XMALLOC(MTYPE_PIM_SSMPINGD, sizeof(*ss));
374 if (!ss) {
375 char source_str[100];
376 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
377 zlog_err("%s: XMALLOC(%zu) failure for ssmpingd source %s",
378 __PRETTY_FUNCTION__,
379 sizeof(*ss), source_str);
380 close(sock_fd);
381 return 0;
382 }
383
384 ss->sock_fd = sock_fd;
385 ss->t_sock_read = 0;
386 ss->source_addr = source_addr;
387 ss->creation = pim_time_monotonic_sec();
388 ss->requests = 0;
389
390 listnode_add(qpim_ssmpingd_list, ss);
391
392 ssmpingd_read_on(ss);
393
394 return ss;
395 }
396
pim_ssmpingd_start(struct in_addr source_addr)397 int pim_ssmpingd_start(struct in_addr source_addr)
398 {
399 struct ssmpingd_sock *ss;
400
401 ss = ssmpingd_find(source_addr);
402 if (ss) {
403 /* silently ignore request to recreate entry */
404 return 0;
405 }
406
407 {
408 char source_str[100];
409 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
410 zlog_info("%s: starting ssmpingd for source %s",
411 __PRETTY_FUNCTION__, source_str);
412 }
413
414 ss = ssmpingd_new(source_addr);
415 if (!ss) {
416 char source_str[100];
417 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
418 zlog_warn("%s: ssmpingd_new() failure for source %s",
419 __PRETTY_FUNCTION__, source_str);
420 return -1;
421 }
422
423 return 0;
424 }
425
pim_ssmpingd_stop(struct in_addr source_addr)426 int pim_ssmpingd_stop(struct in_addr source_addr)
427 {
428 struct ssmpingd_sock *ss;
429
430 ss = ssmpingd_find(source_addr);
431 if (!ss) {
432 char source_str[100];
433 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
434 zlog_warn("%s: could not find ssmpingd for source %s",
435 __PRETTY_FUNCTION__, source_str);
436 return -1;
437 }
438
439 {
440 char source_str[100];
441 pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
442 zlog_info("%s: stopping ssmpingd for source %s",
443 __PRETTY_FUNCTION__, source_str);
444 }
445
446 ssmpingd_delete(ss);
447
448 return 0;
449 }
450