Never free an skb that has been passed to genlmsg_reply().
[sliver-openvswitch.git] / secchan / in-band.c
1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
2  * Junior University
3  *
4  * We are making the OpenFlow specification and associated documentation
5  * (Software) available for public use and benefit with the expectation
6  * that others will use, modify and enhance the Software and contribute
7  * those enhancements back to the community. However, since we would
8  * like to make the Software available for broadest use, with as few
9  * restrictions as possible permission is hereby granted, free of
10  * charge, to any person obtaining a copy of this Software to deal in
11  * the Software under the copyrights without restriction, including
12  * without limitation the rights to use, copy, modify, merge, publish,
13  * distribute, sublicense, and/or sell copies of the Software, and to
14  * permit persons to whom the Software is furnished to do so, subject to
15  * the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be
18  * included in all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27  * SOFTWARE.
28  *
29  * The name and trademarks of copyright holder(s) may NOT be used in
30  * advertising or publicity pertaining to the Software or any
31  * derivatives without specific, written prior permission.
32  */
33
34 #include <config.h>
35 #include "in-band.h"
36 #include <arpa/inet.h>
37 #include <errno.h>
38 #include <inttypes.h>
39 #include <string.h>
40 #include "flow.h"
41 #include "mac-learning.h"
42 #include "netdev.h"
43 #include "ofpbuf.h"
44 #include "openflow/openflow.h"
45 #include "packets.h"
46 #include "port-watcher.h"
47 #include "rconn.h"
48 #include "secchan.h"
49 #include "status.h"
50 #include "timeval.h"
51 #include "vconn.h"
52
53 #define THIS_MODULE VLM_in_band
54 #include "vlog.h"
55
56 struct in_band_data {
57     const struct settings *s;
58     struct mac_learning *ml;
59     struct netdev *of_device;
60     struct rconn *controller;
61     int n_queued;
62 };
63
64 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
65
66 static void
67 queue_tx(struct rconn *rc, struct in_band_data *in_band, struct ofpbuf *b)
68 {
69     rconn_send_with_limit(rc, b, &in_band->n_queued, 10);
70 }
71
72 static const uint8_t *
73 get_controller_mac(struct in_band_data *in_band)
74 {
75     static uint32_t ip, last_nonzero_ip;
76     static uint8_t mac[ETH_ADDR_LEN], last_nonzero_mac[ETH_ADDR_LEN];
77     static time_t next_refresh = 0;
78
79     uint32_t last_ip = ip;
80
81     time_t now = time_now();
82
83     ip = rconn_get_ip(in_band->controller);
84     if (last_ip != ip || !next_refresh || now >= next_refresh) {
85         bool have_mac;
86
87         /* Look up MAC address. */
88         memset(mac, 0, sizeof mac);
89         if (ip && in_band->of_device) {
90             int retval = netdev_arp_lookup(in_band->of_device, ip, mac);
91             if (retval) {
92                 VLOG_DBG_RL(&rl, "cannot look up controller hw address "
93                             "("IP_FMT"): %s", IP_ARGS(&ip), strerror(retval));
94             }
95         }
96         have_mac = !eth_addr_is_zero(mac);
97
98         /* Log changes in IP, MAC addresses. */
99         if (ip && ip != last_nonzero_ip) {
100             VLOG_DBG("controller IP address changed from "IP_FMT
101                      " to "IP_FMT, IP_ARGS(&last_nonzero_ip), IP_ARGS(&ip));
102             last_nonzero_ip = ip;
103         }
104         if (have_mac && memcmp(last_nonzero_mac, mac, ETH_ADDR_LEN)) {
105             VLOG_DBG("controller MAC address changed from "ETH_ADDR_FMT" to "
106                      ETH_ADDR_FMT,
107                      ETH_ADDR_ARGS(last_nonzero_mac), ETH_ADDR_ARGS(mac));
108             memcpy(last_nonzero_mac, mac, ETH_ADDR_LEN);
109         }
110
111         /* Schedule next refresh.
112          *
113          * If we have an IP address but not a MAC address, then refresh
114          * quickly, since we probably will get a MAC address soon (via ARP).
115          * Otherwise, we can afford to wait a little while. */
116         next_refresh = now + (!ip || have_mac ? 10 : 1);
117     }
118     return !eth_addr_is_zero(mac) ? mac : NULL;
119 }
120
121 static bool
122 is_controller_mac(const uint8_t dl_addr[ETH_ADDR_LEN],
123                   struct in_band_data *in_band)
124 {
125     const uint8_t *mac = get_controller_mac(in_band);
126     return mac && eth_addr_equals(mac, dl_addr);
127 }
128
129 static void
130 in_band_learn_mac(struct in_band_data *in_band,
131                   uint16_t in_port, const uint8_t src_mac[ETH_ADDR_LEN])
132 {
133     if (mac_learning_learn(in_band->ml, src_mac, in_port)) {
134         VLOG_DBG_RL(&rl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
135                     ETH_ADDR_ARGS(src_mac), in_port);
136     }
137 }
138
139 static bool
140 in_band_local_packet_cb(struct relay *r, void *in_band_)
141 {
142     struct in_band_data *in_band = in_band_;
143     struct rconn *rc = r->halves[HALF_LOCAL].rconn;
144     struct ofp_packet_in *opi;
145     struct eth_header *eth;
146     struct ofpbuf payload;
147     struct flow flow;
148     uint16_t in_port;
149     int out_port;
150
151     if (!get_ofp_packet_eth_header(r, &opi, &eth) || !in_band->of_device) {
152         return false;
153     }
154     in_port = ntohs(opi->in_port);
155
156     /* Deal with local stuff. */
157     if (in_port == OFPP_LOCAL) {
158         /* Sent by secure channel. */
159         out_port = mac_learning_lookup(in_band->ml, eth->eth_dst);
160     } else if (eth_addr_equals(eth->eth_dst,
161                                netdev_get_etheraddr(in_band->of_device))) {
162         /* Sent to secure channel. */
163         out_port = OFPP_LOCAL;
164         in_band_learn_mac(in_band, in_port, eth->eth_src);
165     } else if (eth->eth_type == htons(ETH_TYPE_ARP)
166                && eth_addr_is_broadcast(eth->eth_dst)
167                && is_controller_mac(eth->eth_src, in_band)) {
168         /* ARP sent by controller. */
169         out_port = OFPP_FLOOD;
170     } else if (is_controller_mac(eth->eth_dst, in_band)
171                || is_controller_mac(eth->eth_src, in_band)) {
172         /* Traffic to or from controller.  Switch it by hand. */
173         in_band_learn_mac(in_band, in_port, eth->eth_src);
174         out_port = mac_learning_lookup(in_band->ml, eth->eth_dst);
175     } else {
176         const uint8_t *controller_mac;
177         controller_mac = get_controller_mac(in_band);
178         if (eth->eth_type == htons(ETH_TYPE_ARP)
179             && eth_addr_is_broadcast(eth->eth_dst)
180             && is_controller_mac(eth->eth_src, in_band)) {
181             /* ARP sent by controller. */
182             out_port = OFPP_FLOOD;
183         } else if (is_controller_mac(eth->eth_dst, in_band)
184                    && in_port == mac_learning_lookup(in_band->ml,
185                                                      controller_mac)) {
186             /* Drop controller traffic that arrives on the controller port. */
187             out_port = -1;
188         } else {
189             return false;
190         }
191     }
192
193     get_ofp_packet_payload(opi, &payload);
194     flow_extract(&payload, in_port, &flow);
195     if (in_port == out_port) {
196         /* The input and output port match.  Set up a flow to drop packets. */
197         queue_tx(rc, in_band, make_add_flow(&flow, ntohl(opi->buffer_id),
198                                           in_band->s->max_idle, 0));
199     } else if (out_port != OFPP_FLOOD) {
200         /* The output port is known, so add a new flow. */
201         queue_tx(rc, in_band,
202                  make_add_simple_flow(&flow, ntohl(opi->buffer_id),
203                                       out_port, in_band->s->max_idle));
204
205         /* If the switch didn't buffer the packet, we need to send a copy. */
206         if (ntohl(opi->buffer_id) == UINT32_MAX) {
207             queue_tx(rc, in_band,
208                      make_unbuffered_packet_out(&payload, in_port, out_port));
209         }
210     } else {
211         /* We don't know that MAC.  Send along the packet without setting up a
212          * flow. */
213         struct ofpbuf *b;
214         if (ntohl(opi->buffer_id) == UINT32_MAX) {
215             b = make_unbuffered_packet_out(&payload, in_port, out_port);
216         } else {
217             b = make_buffered_packet_out(ntohl(opi->buffer_id),
218                                          in_port, out_port);
219         }
220         queue_tx(rc, in_band, b);
221     }
222     return true;
223 }
224
225 static void
226 in_band_status_cb(struct status_reply *sr, void *in_band_)
227 {
228     struct in_band_data *in_band = in_band_;
229     struct in_addr local_ip;
230     uint32_t controller_ip;
231     const uint8_t *controller_mac;
232
233     if (in_band->of_device) {
234         const uint8_t *mac = netdev_get_etheraddr(in_band->of_device);
235         if (netdev_get_in4(in_band->of_device, &local_ip)) {
236             status_reply_put(sr, "local-ip="IP_FMT, IP_ARGS(&local_ip.s_addr));
237         }
238         status_reply_put(sr, "local-mac="ETH_ADDR_FMT, ETH_ADDR_ARGS(mac));
239
240         controller_ip = rconn_get_ip(in_band->controller);
241         if (controller_ip) {
242             status_reply_put(sr, "controller-ip="IP_FMT,
243                              IP_ARGS(&controller_ip));
244         }
245         controller_mac = get_controller_mac(in_band);
246         if (controller_mac) {
247             status_reply_put(sr, "controller-mac="ETH_ADDR_FMT,
248                              ETH_ADDR_ARGS(controller_mac));
249         }
250     }
251 }
252
253 void
254 get_ofp_packet_payload(struct ofp_packet_in *opi, struct ofpbuf *payload)
255 {
256     payload->data = opi->data;
257     payload->size = ntohs(opi->header.length) - offsetof(struct ofp_packet_in,
258                                                          data);
259 }
260
261 static void
262 in_band_local_port_cb(const struct ofp_phy_port *port, void *in_band_)
263 {
264     struct in_band_data *in_band = in_band_;
265     if (port) {
266         char name[sizeof port->name + 1];
267         get_port_name(port, name, sizeof name);
268
269         if (!in_band->of_device
270             || strcmp(netdev_get_name(in_band->of_device), name))
271         {
272             int error;
273             netdev_close(in_band->of_device);
274             error = netdev_open(name, NETDEV_ETH_TYPE_NONE,
275                                 &in_band->of_device);
276             if (error) {
277                 VLOG_ERR("failed to open in-band control network device "
278                          "\"%s\": %s", name, strerror(errno));
279             }
280         }
281     } else {
282         netdev_close(in_band->of_device);
283         in_band->of_device = NULL;
284     }
285 }
286
287 static struct hook_class in_band_hook_class = {
288     in_band_local_packet_cb,    /* local_packet_cb */
289     NULL,                       /* remote_packet_cb */
290     NULL,                       /* periodic_cb */
291     NULL,                       /* wait_cb */
292     NULL,                       /* closing_cb */
293 };
294
295 void
296 in_band_start(struct secchan *secchan,
297               const struct settings *s, struct switch_status *ss,
298               struct port_watcher *pw, struct rconn *remote)
299 {
300     struct in_band_data *in_band;
301
302     in_band = xcalloc(1, sizeof *in_band);
303     in_band->s = s;
304     in_band->ml = mac_learning_create();
305     in_band->of_device = NULL;
306     in_band->controller = remote;
307     switch_status_register_category(ss, "in-band", in_band_status_cb, in_band);
308     port_watcher_register_local_port_callback(pw, in_band_local_port_cb,
309                                               in_band);
310     add_hook(secchan, &in_band_hook_class, in_band);
311 }