[NETFILTER]: ebt_mark: add or/and/xor action support to mark target
[linux-2.6.git] / net / bridge / br_netlink.c
1 /*
2  *      Bridge netlink control interface
3  *
4  *      Authors:
5  *      Stephen Hemminger               <shemminger@osdl.org>
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License
9  *      as published by the Free Software Foundation; either version
10  *      2 of the License, or (at your option) any later version.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/rtnetlink.h>
15 #include <net/netlink.h>
16 #include "br_private.h"
17
18 /*
19  * Create one netlink message for one interface
20  * Contains port and master info as well as carrier and bridge state.
21  */
22 static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *port,
23                           u32 pid, u32 seq, int event, unsigned int flags)
24 {
25         const struct net_bridge *br = port->br;
26         const struct net_device *dev = port->dev;
27         struct ifinfomsg *r;
28         struct nlmsghdr *nlh;
29         unsigned char *b = skb->tail;
30         u32 mtu = dev->mtu;
31         u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
32         u8 portstate = port->state;
33
34         pr_debug("br_fill_info event %d port %s master %s\n",
35                  event, dev->name, br->dev->name);
36
37         nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*r), flags);
38         r = NLMSG_DATA(nlh);
39         r->ifi_family = AF_BRIDGE;
40         r->__ifi_pad = 0;
41         r->ifi_type = dev->type;
42         r->ifi_index = dev->ifindex;
43         r->ifi_flags = dev_get_flags(dev);
44         r->ifi_change = 0;
45
46         RTA_PUT(skb, IFLA_IFNAME, strlen(dev->name)+1, dev->name);
47
48         RTA_PUT(skb, IFLA_MASTER, sizeof(int), &br->dev->ifindex);
49
50         if (dev->addr_len)
51                 RTA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
52
53         RTA_PUT(skb, IFLA_MTU, sizeof(mtu), &mtu);
54         if (dev->ifindex != dev->iflink)
55                 RTA_PUT(skb, IFLA_LINK, sizeof(int), &dev->iflink);
56
57
58         RTA_PUT(skb, IFLA_OPERSTATE, sizeof(operstate), &operstate);
59
60         if (event == RTM_NEWLINK)
61                 RTA_PUT(skb, IFLA_PROTINFO, sizeof(portstate), &portstate);
62
63         nlh->nlmsg_len = skb->tail - b;
64
65         return skb->len;
66
67 nlmsg_failure:
68 rtattr_failure:
69
70         skb_trim(skb, b - skb->data);
71         return -EINVAL;
72 }
73
74 /*
75  * Notify listeners of a change in port information
76  */
77 void br_ifinfo_notify(int event, struct net_bridge_port *port)
78 {
79         struct sk_buff *skb;
80         int payload = sizeof(struct ifinfomsg) + 128;
81         int err = -ENOBUFS;
82
83         pr_debug("bridge notify event=%d\n", event);
84         skb = nlmsg_new(nlmsg_total_size(payload), GFP_ATOMIC);
85         if (skb == NULL)
86                 goto errout;
87
88         err = br_fill_ifinfo(skb, port, 0, 0, event, 0);
89         if (err < 0) {
90                 kfree_skb(skb);
91                 goto errout;
92         }
93
94         err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
95 errout:
96         if (err < 0)
97                 rtnl_set_sk_err(RTNLGRP_LINK, err);
98 }
99
100 /*
101  * Dump information about all ports, in response to GETLINK
102  */
103 static int br_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
104 {
105         struct net_device *dev;
106         int idx;
107         int s_idx = cb->args[0];
108         int err = 0;
109
110         read_lock(&dev_base_lock);
111         for (dev = dev_base, idx = 0; dev; dev = dev->next) {
112                 struct net_bridge_port *p = dev->br_port;
113
114                 /* not a bridge port */
115                 if (!p)
116                         continue;
117
118                 if (idx < s_idx)
119                         goto cont;
120
121                 err = br_fill_ifinfo(skb, p, NETLINK_CB(cb->skb).pid,
122                                      cb->nlh->nlmsg_seq, RTM_NEWLINK, NLM_F_MULTI);
123                 if (err <= 0)
124                         break;
125 cont:
126                 ++idx;
127         }
128         read_unlock(&dev_base_lock);
129
130         cb->args[0] = idx;
131
132         return skb->len;
133 }
134
135 /*
136  * Change state of port (ie from forwarding to blocking etc)
137  * Used by spanning tree in user space.
138  */
139 static int br_rtm_setlink(struct sk_buff *skb,  struct nlmsghdr *nlh, void *arg)
140 {
141         struct rtattr  **rta = arg;
142         struct ifinfomsg *ifm = NLMSG_DATA(nlh);
143         struct net_device *dev;
144         struct net_bridge_port *p;
145         u8 new_state;
146
147         if (ifm->ifi_family != AF_BRIDGE)
148                 return -EPFNOSUPPORT;
149
150         /* Must pass valid state as PROTINFO */
151         if (rta[IFLA_PROTINFO-1]) {
152                 u8 *pstate = RTA_DATA(rta[IFLA_PROTINFO-1]);
153                 new_state = *pstate;
154         } else
155                 return -EINVAL;
156
157         if (new_state > BR_STATE_BLOCKING)
158                 return -EINVAL;
159
160         /* Find bridge port */
161         dev = __dev_get_by_index(ifm->ifi_index);
162         if (!dev)
163                 return -ENODEV;
164
165         p = dev->br_port;
166         if (!p)
167                 return -EINVAL;
168
169         /* if kernel STP is running, don't allow changes */
170         if (p->br->stp_enabled)
171                 return -EBUSY;
172
173         if (!netif_running(dev))
174                 return -ENETDOWN;
175
176         if (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED)
177                 return -ENETDOWN;
178
179         p->state = new_state;
180         br_log_state(p);
181         return 0;
182 }
183
184
185 static struct rtnetlink_link bridge_rtnetlink_table[RTM_NR_MSGTYPES] = {
186         [RTM_GETLINK - RTM_BASE] = { .dumpit    = br_dump_ifinfo, },
187         [RTM_SETLINK - RTM_BASE] = { .doit      = br_rtm_setlink, },
188 };
189
190 void __init br_netlink_init(void)
191 {
192         rtnetlink_links[PF_BRIDGE] = bridge_rtnetlink_table;
193 }
194
195 void __exit br_netlink_fini(void)
196 {
197         rtnetlink_links[PF_BRIDGE] = NULL;
198 }
199