net: heap overflow in __audit_sockaddr()
[linux-3.10.git] / net / mac802154 / mib.c
1 /*
2  * Copyright 2007-2012 Siemens AG
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2
6  * as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License along
14  * with this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16  *
17  * Written by:
18  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
19  * Sergey Lapin <slapin@ossfans.org>
20  * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
21  * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
22  */
23
24 #include <linux/if_arp.h>
25
26 #include <net/mac802154.h>
27 #include <net/wpan-phy.h>
28
29 #include "mac802154.h"
30
31 struct phy_chan_notify_work {
32         struct work_struct work;
33         struct net_device *dev;
34 };
35
36 struct hw_addr_filt_notify_work {
37         struct work_struct work;
38         struct net_device *dev;
39         unsigned long changed;
40 };
41
42 static struct mac802154_priv *mac802154_slave_get_priv(struct net_device *dev)
43 {
44         struct mac802154_sub_if_data *priv = netdev_priv(dev);
45
46         BUG_ON(dev->type != ARPHRD_IEEE802154);
47
48         return priv->hw;
49 }
50
51 static void hw_addr_notify(struct work_struct *work)
52 {
53         struct hw_addr_filt_notify_work *nw = container_of(work,
54                         struct hw_addr_filt_notify_work, work);
55         struct mac802154_priv *hw = mac802154_slave_get_priv(nw->dev);
56         int res;
57
58         res = hw->ops->set_hw_addr_filt(&hw->hw,
59                                         &hw->hw.hw_filt,
60                                         nw->changed);
61         if (res)
62                 pr_debug("failed changed mask %lx\n", nw->changed);
63
64         kfree(nw);
65
66         return;
67 }
68
69 static void set_hw_addr_filt(struct net_device *dev, unsigned long changed)
70 {
71         struct mac802154_sub_if_data *priv = netdev_priv(dev);
72         struct hw_addr_filt_notify_work *work;
73
74         work = kzalloc(sizeof(*work), GFP_ATOMIC);
75         if (!work)
76                 return;
77
78         INIT_WORK(&work->work, hw_addr_notify);
79         work->dev = dev;
80         work->changed = changed;
81         queue_work(priv->hw->dev_workqueue, &work->work);
82
83         return;
84 }
85
86 void mac802154_dev_set_short_addr(struct net_device *dev, u16 val)
87 {
88         struct mac802154_sub_if_data *priv = netdev_priv(dev);
89
90         BUG_ON(dev->type != ARPHRD_IEEE802154);
91
92         spin_lock_bh(&priv->mib_lock);
93         priv->short_addr = val;
94         spin_unlock_bh(&priv->mib_lock);
95
96         if ((priv->hw->ops->set_hw_addr_filt) &&
97             (priv->hw->hw.hw_filt.short_addr != priv->short_addr)) {
98                 priv->hw->hw.hw_filt.short_addr = priv->short_addr;
99                 set_hw_addr_filt(dev, IEEE802515_AFILT_SADDR_CHANGED);
100         }
101 }
102
103 u16 mac802154_dev_get_short_addr(const struct net_device *dev)
104 {
105         struct mac802154_sub_if_data *priv = netdev_priv(dev);
106         u16 ret;
107
108         BUG_ON(dev->type != ARPHRD_IEEE802154);
109
110         spin_lock_bh(&priv->mib_lock);
111         ret = priv->short_addr;
112         spin_unlock_bh(&priv->mib_lock);
113
114         return ret;
115 }
116
117 void mac802154_dev_set_ieee_addr(struct net_device *dev)
118 {
119         struct mac802154_sub_if_data *priv = netdev_priv(dev);
120         struct mac802154_priv *mac = priv->hw;
121
122         if (mac->ops->set_hw_addr_filt &&
123             memcmp(mac->hw.hw_filt.ieee_addr,
124                    dev->dev_addr, IEEE802154_ADDR_LEN)) {
125                 memcpy(mac->hw.hw_filt.ieee_addr,
126                        dev->dev_addr, IEEE802154_ADDR_LEN);
127                 set_hw_addr_filt(dev, IEEE802515_AFILT_IEEEADDR_CHANGED);
128         }
129 }
130
131 u16 mac802154_dev_get_pan_id(const struct net_device *dev)
132 {
133         struct mac802154_sub_if_data *priv = netdev_priv(dev);
134         u16 ret;
135
136         BUG_ON(dev->type != ARPHRD_IEEE802154);
137
138         spin_lock_bh(&priv->mib_lock);
139         ret = priv->pan_id;
140         spin_unlock_bh(&priv->mib_lock);
141
142         return ret;
143 }
144
145 void mac802154_dev_set_pan_id(struct net_device *dev, u16 val)
146 {
147         struct mac802154_sub_if_data *priv = netdev_priv(dev);
148
149         BUG_ON(dev->type != ARPHRD_IEEE802154);
150
151         spin_lock_bh(&priv->mib_lock);
152         priv->pan_id = val;
153         spin_unlock_bh(&priv->mib_lock);
154
155         if ((priv->hw->ops->set_hw_addr_filt) &&
156             (priv->hw->hw.hw_filt.pan_id != priv->pan_id)) {
157                 priv->hw->hw.hw_filt.pan_id = priv->pan_id;
158                 set_hw_addr_filt(dev, IEEE802515_AFILT_PANID_CHANGED);
159         }
160 }
161
162 u8 mac802154_dev_get_dsn(const struct net_device *dev)
163 {
164         struct mac802154_sub_if_data *priv = netdev_priv(dev);
165
166         BUG_ON(dev->type != ARPHRD_IEEE802154);
167
168         return priv->dsn++;
169 }
170
171 static void phy_chan_notify(struct work_struct *work)
172 {
173         struct phy_chan_notify_work *nw = container_of(work,
174                                           struct phy_chan_notify_work, work);
175         struct mac802154_priv *hw = mac802154_slave_get_priv(nw->dev);
176         struct mac802154_sub_if_data *priv = netdev_priv(nw->dev);
177         int res;
178
179         mutex_lock(&priv->hw->phy->pib_lock);
180         res = hw->ops->set_channel(&hw->hw, priv->page, priv->chan);
181         if (res)
182                 pr_debug("set_channel failed\n");
183         else {
184                 priv->hw->phy->current_channel = priv->chan;
185                 priv->hw->phy->current_page = priv->page;
186         }
187         mutex_unlock(&priv->hw->phy->pib_lock);
188
189         kfree(nw);
190 }
191
192 void mac802154_dev_set_page_channel(struct net_device *dev, u8 page, u8 chan)
193 {
194         struct mac802154_sub_if_data *priv = netdev_priv(dev);
195         struct phy_chan_notify_work *work;
196
197         BUG_ON(dev->type != ARPHRD_IEEE802154);
198
199         spin_lock_bh(&priv->mib_lock);
200         priv->page = page;
201         priv->chan = chan;
202         spin_unlock_bh(&priv->mib_lock);
203
204         mutex_lock(&priv->hw->phy->pib_lock);
205         if (priv->hw->phy->current_channel != priv->chan ||
206             priv->hw->phy->current_page != priv->page) {
207                 mutex_unlock(&priv->hw->phy->pib_lock);
208
209                 work = kzalloc(sizeof(*work), GFP_ATOMIC);
210                 if (!work)
211                         return;
212
213                 INIT_WORK(&work->work, phy_chan_notify);
214                 work->dev = dev;
215                 queue_work(priv->hw->dev_workqueue, &work->work);
216         } else
217                 mutex_unlock(&priv->hw->phy->pib_lock);
218 }