Annotation of embedaddon/quagga/pimd/pim_ssmpingd.c, revision 1.1
1.1 ! misho 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:
! 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:
! 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:
! 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:
! 78: static void ssmpingd_free(struct ssmpingd_sock *ss)
! 79: {
! 80: XFREE(MTYPE_PIM_SSMPINGD, ss);
! 81: }
! 82:
! 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:
! 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:
! 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:
! 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:
! 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:
! 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:
! 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:
! 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:
! 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_ssmpingd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / pimd