[people/ms/rstp.git] / brmon.c

/*
 * brmon.c		RTnetlink listener.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	Stephen Hemminger <shemminger@osdl.org>
 *
 *              Modified by Srinivas Aji <Aji_Srinivas@emc.com> for use
 *              in RSTP daemon. - 2006-09-01
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_bridge.h>
#include <string.h>

#include "libnetlink.h"

#include "bridge_ctl.h"

static const char SNAPSHOT[] = "v0.1";


/* RFC 2863 operational status */
enum {
	IF_OPER_UNKNOWN,
	IF_OPER_NOTPRESENT,
	IF_OPER_DOWN,
	IF_OPER_LOWERLAYERDOWN,
	IF_OPER_TESTING,
	IF_OPER_DORMANT,
	IF_OPER_UP,
};

/* link modes */
enum {
	IF_LINK_MODE_DEFAULT,
	IF_LINK_MODE_DORMANT,	/* limit upward transition to dormant */
};

static const char *port_states[] = {
	[BR_STATE_DISABLED] = "disabled",
	[BR_STATE_LISTENING] = "listening",
	[BR_STATE_LEARNING] = "learning",
	[BR_STATE_FORWARDING] = "forwarding",
	[BR_STATE_BLOCKING] = "blocking",
};


static int dump_msg(const struct sockaddr_nl *who, struct nlmsghdr *n,
		    void *arg)
{
	FILE *fp = arg;
	struct ifinfomsg *ifi = NLMSG_DATA(n);
	struct rtattr * tb[IFLA_MAX+1];
	int len = n->nlmsg_len;
	char b1[IFNAMSIZ];
	int af_family = ifi->ifi_family;

        if (n->nlmsg_type == NLMSG_DONE)
          return 0;
        
	len -= NLMSG_LENGTH(sizeof(*ifi));
	if (len < 0) {
          return -1;
        }
        
#if 0

	if (filter.ifindex && ifi->ifi_index != filter.ifindex)
		return 0;

	if (filter.up && !(ifi->ifi_flags&IFF_UP))
		return 0;
#endif
        if (ifi->ifi_family != AF_BRIDGE && ifi->ifi_family != AF_UNSPEC)
          return 0;

        if (n->nlmsg_type != RTM_NEWLINK &&
            n->nlmsg_type != RTM_DELLINK)
          return 0;

	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);

        /* Check if we got this from bonding */
        if (tb[IFLA_MASTER] && af_family != AF_BRIDGE)
          return 0;

        /* Check for BPDU */
        if (tb[IFLA_PRIORITY] && af_family == AF_BRIDGE) {
          bridge_bpdu_rcv(ifi->ifi_index,
                   RTA_DATA(tb[IFLA_PRIORITY]),
                   RTA_PAYLOAD(tb[IFLA_PRIORITY]));
          return 0;
        }

	if (tb[IFLA_IFNAME] == NULL) {
		fprintf(stderr, "BUG: nil ifname\n");
		return -1;
	}

	if (n->nlmsg_type == RTM_DELLINK)
		fprintf(fp, "Deleted ");

	fprintf(fp, "%d: %s ", ifi->ifi_index,
		tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");


	if (tb[IFLA_OPERSTATE]) {
		int state = *(int*)RTA_DATA(tb[IFLA_OPERSTATE]);
		switch (state) {
		case IF_OPER_UNKNOWN: 
			fprintf(fp, "Unknown "); break;
		case IF_OPER_NOTPRESENT:
			fprintf(fp, "Not Present "); break;
		case IF_OPER_DOWN:
			fprintf(fp, "Down "); break;
		case IF_OPER_LOWERLAYERDOWN:
			fprintf(fp, "Lowerlayerdown "); break;
		case IF_OPER_TESTING:
			fprintf(fp, "Testing "); break;
		case IF_OPER_DORMANT:
			fprintf(fp, "Dormant "); break;
		case IF_OPER_UP:
			fprintf(fp, "Up "); break;
		default:
			fprintf(fp, "State(%d) ", state);
		}
	}
	
	if (tb[IFLA_MTU])
		fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));

	if (tb[IFLA_MASTER]) {
		fprintf(fp, "master %s ", 
			if_indextoname(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
	}

	if (tb[IFLA_PROTINFO]) {
		uint8_t state = *(uint8_t *)RTA_DATA(tb[IFLA_PROTINFO]);
		if (state <= BR_STATE_BLOCKING)
			fprintf(fp, "state %s", port_states[state]);
		else
			fprintf(fp, "state (%d)", state);
	}


	fprintf(fp, "\n");
	fflush(fp);
        {
          int newlink = (n->nlmsg_type == RTM_NEWLINK);
          int up = 0;
          if (newlink && tb[IFLA_OPERSTATE]) {
            int state = *(int*)RTA_DATA(tb[IFLA_OPERSTATE]);
            up = (state == IF_OPER_UP) || (state == IF_OPER_UNKNOWN);
          }

          bridge_notify((tb[IFLA_MASTER]?*(int*)RTA_DATA(tb[IFLA_MASTER]):-1), 
                        ifi->ifi_index, newlink, up);
        }
	return 0;
}

#if 0
static void usage(void)
{
	fprintf(stderr, "Usage: brmon\n");
	exit(-1);
}

static int matches(const char *cmd, const char *pattern)
{
	int len = strlen(cmd);
	if (len > strlen(pattern))
		return -1;
	return memcmp(pattern, cmd, len);
}

int
main(int argc, char **argv)
{
	struct rtnl_handle rth;
	unsigned groups = ~RTMGRP_TC;
	int llink = 0;
	int laddr = 0;

	while (argc > 1) {
		if (matches(argv[1], "-Version") == 0) {
			printf("brmon %s\n", SNAPSHOT);
			exit(0);
		} else if (matches(argv[1], "link") == 0) {
			llink=1;
			groups = 0;
		} else if (matches(argv[1], "bridge") == 0) {
			laddr=1;
			groups = 0;
		} else if (strcmp(argv[1], "all") == 0) {
			groups = ~RTMGRP_TC;
		} else if (matches(argv[1], "help") == 0) {
			usage();
		} else {
			fprintf(stderr, "Argument \"%s\" is unknown, try \"rtmon help\".\n", argv[1]);
			exit(-1);
		}
		argc--;	argv++;
	}

	if (llink)
		groups |= RTMGRP_LINK;

	if (rtnl_open(&rth, groups) < 0)
		exit(1);

	if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
		perror("Cannot send dump request");
		exit(1);
	}

	if (rtnl_dump_filter(&rth, dump_msg, stdout, NULL, NULL) < 0) {
		fprintf(stderr, "Dump terminated\n");
		return 1;
	}

	if (rtnl_listen(&rth, dump_msg, stdout) < 0)
		exit(2);

	exit(0);
}
#endif

#include "bridge_ctl.h"
#include "epoll_loop.h"

struct rtnl_handle rth;
struct epoll_event_handler br_handler;

struct rtnl_handle rth_state;

void br_ev_handler(uint32_t events, struct epoll_event_handler *h)
{
  if (rtnl_listen(&rth, dump_msg, stdout) < 0) {
    fprintf(stderr, "Error on bridge monitoring socket\n");
    exit(-1);
  }
}

int init_bridge_ops(void)
{
  if (rtnl_open(&rth, ~RTMGRP_TC) < 0) {
    fprintf(stderr, "Couldn't open rtnl socket for monitoring\n");
    return -1;
  }
  
  if (rtnl_open(&rth_state, 0) < 0) {
    fprintf(stderr, "Couldn't open rtnl socket for setting state\n");
    return -1;
  }

  if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
    fprintf(stderr, "Cannot send dump request: %m\n");
    return -1;
  }
  
  if (rtnl_dump_filter(&rth, dump_msg, stdout, NULL, NULL) < 0) {
    fprintf(stderr, "Dump terminated\n");
    return -1;
  }

  if (fcntl(rth.fd, F_SETFL, O_NONBLOCK) < 0) {
    fprintf(stderr, "Error setting O_NONBLOCK: %m\n");
    return -1;
  }

  br_handler.fd = rth.fd;
  br_handler.arg = NULL;
  br_handler.handler = br_ev_handler;
  
  if (add_epoll(&br_handler) < 0)
    return -1;
  
  return 0;
}

/* Send message. Response is through bridge_notify */
void bridge_get_configuration(void)
{
  if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
    fprintf(stderr, "Cannot send dump request: %m\n");
  }
}
Commit	Line	Data
ad02a0eb SH	1	/*
	2	* brmon.c RTnetlink listener.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: Stephen Hemminger <shemminger@osdl.org>
	10	*
	11	* Modified by Srinivas Aji <Aji_Srinivas@emc.com> for use
	12	* in RSTP daemon. - 2006-09-01
	13	*/
	14
	15	#include <stdio.h>
	16	#include <stdlib.h>
	17	#include <unistd.h>
	18	#include <syslog.h>
	19	#include <fcntl.h>
	20	#include <sys/socket.h>
	21	#include <sys/time.h>
	22	#include <net/if.h>
	23	#include <netinet/in.h>
	24	#include <linux/if_bridge.h>
	25	#include <string.h>
	26
	27	#include "libnetlink.h"
	28
	29	#include "bridge_ctl.h"
	30
	31	static const char SNAPSHOT[] = "v0.1";
	32
96e20123	33
ad02a0eb SH	34	/* RFC 2863 operational status */
	35	enum {
	36	IF_OPER_UNKNOWN,
	37	IF_OPER_NOTPRESENT,
	38	IF_OPER_DOWN,
	39	IF_OPER_LOWERLAYERDOWN,
	40	IF_OPER_TESTING,
	41	IF_OPER_DORMANT,
	42	IF_OPER_UP,
	43	};
	44
	45	/* link modes */
	46	enum {
	47	IF_LINK_MODE_DEFAULT,
	48	IF_LINK_MODE_DORMANT, /* limit upward transition to dormant */
	49	};
	50
	51	static const char *port_states[] = {
	52	[BR_STATE_DISABLED] = "disabled",
	53	[BR_STATE_LISTENING] = "listening",
	54	[BR_STATE_LEARNING] = "learning",
	55	[BR_STATE_FORWARDING] = "forwarding",
	56	[BR_STATE_BLOCKING] = "blocking",
	57	};
	58
96e20123	59
ad02a0eb SH	60	static int dump_msg(const struct sockaddr_nl who, struct nlmsghdr n,
	61	void *arg)
	62	{
	63	FILE *fp = arg;
	64	struct ifinfomsg *ifi = NLMSG_DATA(n);
96e20123	65	struct rtattr * tb[IFLA_MAX+1];
ad02a0eb SH	66	int len = n->nlmsg_len;
	67	char b1[IFNAMSIZ];
	68	int af_family = ifi->ifi_family;
	69
96e20123 SH	70	if (n->nlmsg_type == NLMSG_DONE)
	71	return 0;
	72
ad02a0eb SH	73	len -= NLMSG_LENGTH(sizeof(*ifi));
ad02a0eb SH	74	if (len < 0) {
96e20123 SH	75	return -1;
	76	}
	77
ad02a0eb SH	78	#if 0
	79
	80	if (filter.ifindex && ifi->ifi_index != filter.ifindex)
	81	return 0;
	82
96e20123	83	if (filter.up && !(ifi->ifi_flags&IFF_UP))
ad02a0eb SH	84	return 0;
ad02a0eb SH	85	#endif
96e20123 SH	86	if (ifi->ifi_family != AF_BRIDGE && ifi->ifi_family != AF_UNSPEC)
96e20123 SH	87	return 0;
ad02a0eb	88
96e20123 SH	89	if (n->nlmsg_type != RTM_NEWLINK &&
	90	n->nlmsg_type != RTM_DELLINK)
	91	return 0;
ad02a0eb SH	92
	93	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
	94
96e20123 SH	95	/* Check if we got this from bonding */
	96	if (tb[IFLA_MASTER] && af_family != AF_BRIDGE)
	97	return 0;
ad02a0eb	98
96e20123 SH	99	/* Check for BPDU */
	100	if (tb[IFLA_PRIORITY] && af_family == AF_BRIDGE) {
	101	bridge_bpdu_rcv(ifi->ifi_index,
	102	RTA_DATA(tb[IFLA_PRIORITY]),
	103	RTA_PAYLOAD(tb[IFLA_PRIORITY]));
	104	return 0;
	105	}
ad02a0eb SH	106
	107	if (tb[IFLA_IFNAME] == NULL) {
	108	fprintf(stderr, "BUG: nil ifname\n");
	109	return -1;
	110	}
	111
	112	if (n->nlmsg_type == RTM_DELLINK)
	113	fprintf(fp, "Deleted ");
	114
	115	fprintf(fp, "%d: %s ", ifi->ifi_index,
96e20123 SH	116	tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");
96e20123 SH	117
ad02a0eb SH	118
ad02a0eb SH	119	if (tb[IFLA_OPERSTATE]) {
96e20123	120	int state = (int)RTA_DATA(tb[IFLA_OPERSTATE]);
ad02a0eb	121	switch (state) {
96e20123 SH	122	case IF_OPER_UNKNOWN:
96e20123 SH	123	fprintf(fp, "Unknown "); break;
ad02a0eb	124	case IF_OPER_NOTPRESENT:
96e20123	125	fprintf(fp, "Not Present "); break;
ad02a0eb	126	case IF_OPER_DOWN:
96e20123	127	fprintf(fp, "Down "); break;
ad02a0eb	128	case IF_OPER_LOWERLAYERDOWN:
96e20123	129	fprintf(fp, "Lowerlayerdown "); break;
ad02a0eb	130	case IF_OPER_TESTING:
96e20123	131	fprintf(fp, "Testing "); break;
ad02a0eb	132	case IF_OPER_DORMANT:
96e20123	133	fprintf(fp, "Dormant "); break;
ad02a0eb	134	case IF_OPER_UP:
96e20123	135	fprintf(fp, "Up "); break;
ad02a0eb SH	136	default:
	137	fprintf(fp, "State(%d) ", state);
	138	}
	139	}
96e20123	140
ad02a0eb	141	if (tb[IFLA_MTU])
96e20123	142	fprintf(fp, "mtu %u ", (int)RTA_DATA(tb[IFLA_MTU]));
ad02a0eb SH	143
ad02a0eb SH	144	if (tb[IFLA_MASTER]) {
96e20123 SH	145	fprintf(fp, "master %s ",
96e20123 SH	146	if_indextoname((int)RTA_DATA(tb[IFLA_MASTER]), b1));
ad02a0eb SH	147	}
	148
	149	if (tb[IFLA_PROTINFO]) {
96e20123	150	uint8_t state = (uint8_t )RTA_DATA(tb[IFLA_PROTINFO]);
ad02a0eb SH	151	if (state <= BR_STATE_BLOCKING)
	152	fprintf(fp, "state %s", port_states[state]);
	153	else
	154	fprintf(fp, "state (%d)", state);
	155	}
	156
96e20123	157
ad02a0eb SH	158	fprintf(fp, "\n");
ad02a0eb SH	159	fflush(fp);
96e20123 SH	160	{
	161	int newlink = (n->nlmsg_type == RTM_NEWLINK);
	162	int up = 0;
	163	if (newlink && tb[IFLA_OPERSTATE]) {
	164	int state = (int)RTA_DATA(tb[IFLA_OPERSTATE]);
	165	up = (state == IF_OPER_UP) \|\| (state == IF_OPER_UNKNOWN);
	166	}
	167
	168	bridge_notify((tb[IFLA_MASTER]?(int)RTA_DATA(tb[IFLA_MASTER]):-1),
	169	ifi->ifi_index, newlink, up);
	170	}
ad02a0eb SH	171	return 0;
	172	}
	173
	174	#if 0
	175	static void usage(void)
	176	{
	177	fprintf(stderr, "Usage: brmon\n");
	178	exit(-1);
	179	}
	180
	181	static int matches(const char cmd, const char pattern)
	182	{
	183	int len = strlen(cmd);
	184	if (len > strlen(pattern))
	185	return -1;
	186	return memcmp(pattern, cmd, len);
	187	}
	188
96e20123 SH	189	int
96e20123 SH	190	main(int argc, char **argv)
ad02a0eb SH	191	{
	192	struct rtnl_handle rth;
	193	unsigned groups = ~RTMGRP_TC;
	194	int llink = 0;
	195	int laddr = 0;
	196
	197	while (argc > 1) {
	198	if (matches(argv[1], "-Version") == 0) {
	199	printf("brmon %s\n", SNAPSHOT);
	200	exit(0);
	201	} else if (matches(argv[1], "link") == 0) {
96e20123	202	llink=1;
ad02a0eb SH	203	groups = 0;
ad02a0eb SH	204	} else if (matches(argv[1], "bridge") == 0) {
96e20123	205	laddr=1;
ad02a0eb SH	206	groups = 0;
	207	} else if (strcmp(argv[1], "all") == 0) {
	208	groups = ~RTMGRP_TC;
	209	} else if (matches(argv[1], "help") == 0) {
	210	usage();
	211	} else {
96e20123	212	fprintf(stderr, "Argument \"%s\" is unknown, try \"rtmon help\".\n", argv[1]);
ad02a0eb SH	213	exit(-1);
ad02a0eb SH	214	}
96e20123	215	argc--; argv++;
ad02a0eb SH	216	}
	217
	218	if (llink)
	219	groups \|= RTMGRP_LINK;
	220
	221	if (rtnl_open(&rth, groups) < 0)
	222	exit(1);
	223
	224	if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
	225	perror("Cannot send dump request");
	226	exit(1);
	227	}
	228
	229	if (rtnl_dump_filter(&rth, dump_msg, stdout, NULL, NULL) < 0) {
	230	fprintf(stderr, "Dump terminated\n");
	231	return 1;
	232	}
	233
	234	if (rtnl_listen(&rth, dump_msg, stdout) < 0)
	235	exit(2);
	236
	237	exit(0);
	238	}
	239	#endif
	240
	241	#include "bridge_ctl.h"
	242	#include "epoll_loop.h"
	243
	244	struct rtnl_handle rth;
	245	struct epoll_event_handler br_handler;
	246
	247	struct rtnl_handle rth_state;
	248
	249	void br_ev_handler(uint32_t events, struct epoll_event_handler *h)
	250	{
96e20123 SH	251	if (rtnl_listen(&rth, dump_msg, stdout) < 0) {
	252	fprintf(stderr, "Error on bridge monitoring socket\n");
	253	exit(-1);
	254	}
ad02a0eb SH	255	}
	256
	257	int init_bridge_ops(void)
	258	{
96e20123 SH	259	if (rtnl_open(&rth, ~RTMGRP_TC) < 0) {
	260	fprintf(stderr, "Couldn't open rtnl socket for monitoring\n");
	261	return -1;
	262	}
	263
	264	if (rtnl_open(&rth_state, 0) < 0) {
	265	fprintf(stderr, "Couldn't open rtnl socket for setting state\n");
	266	return -1;
	267	}
	268
	269	if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
	270	fprintf(stderr, "Cannot send dump request: %m\n");
	271	return -1;
	272	}
	273
	274	if (rtnl_dump_filter(&rth, dump_msg, stdout, NULL, NULL) < 0) {
	275	fprintf(stderr, "Dump terminated\n");
	276	return -1;
	277	}
	278
	279	if (fcntl(rth.fd, F_SETFL, O_NONBLOCK) < 0) {
	280	fprintf(stderr, "Error setting O_NONBLOCK: %m\n");
	281	return -1;
	282	}
	283
	284	br_handler.fd = rth.fd;
	285	br_handler.arg = NULL;
	286	br_handler.handler = br_ev_handler;
	287
	288	if (add_epoll(&br_handler) < 0)
	289	return -1;
	290
	291	return 0;
ad02a0eb SH	292	}
	293
	294	/* Send message. Response is through bridge_notify */
	295	void bridge_get_configuration(void)
	296	{
96e20123 SH	297	if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETLINK) < 0) {
	298	fprintf(stderr, "Cannot send dump request: %m\n");
	299	}
ad02a0eb	300	}