Commit | Line | Data |
---|---|---|
9f6446c7 | 1 | /* Copyright (C) 2009-2015 B.A.T.M.A.N. contributors: |
c6c8fea2 SE |
2 | * |
3 | * Marek Lindner | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of version 2 of the GNU General Public | |
7 | * License as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, but | |
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | * General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
ebf38fb7 | 15 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
c6c8fea2 SE |
16 | */ |
17 | ||
c6c8fea2 | 18 | #include "gateway_common.h" |
1e2c2a4f SE |
19 | #include "main.h" |
20 | ||
21 | #include <linux/atomic.h> | |
77927b7d | 22 | #include <linux/errno.h> |
1e2c2a4f SE |
23 | #include <linux/byteorder/generic.h> |
24 | #include <linux/kernel.h> | |
0b8336f5 | 25 | #include <linux/math64.h> |
1e2c2a4f SE |
26 | #include <linux/netdevice.h> |
27 | #include <linux/stddef.h> | |
28 | #include <linux/string.h> | |
29 | ||
c6c8fea2 | 30 | #include "gateway_client.h" |
1e2c2a4f | 31 | #include "packet.h" |
c6c8fea2 | 32 | |
414254e3 ML |
33 | /** |
34 | * batadv_parse_gw_bandwidth - parse supplied string buffer to extract download | |
35 | * and upload bandwidth information | |
36 | * @net_dev: the soft interface net device | |
37 | * @buff: string buffer to parse | |
38 | * @down: pointer holding the returned download bandwidth information | |
39 | * @up: pointer holding the returned upload bandwidth information | |
40 | * | |
41 | * Returns false on parse error and true otherwise. | |
42 | */ | |
8e714a5d | 43 | static bool batadv_parse_gw_bandwidth(struct net_device *net_dev, char *buff, |
6b5e971a | 44 | u32 *down, u32 *up) |
c6c8fea2 | 45 | { |
414254e3 | 46 | enum batadv_bandwidth_units bw_unit_type = BATADV_BW_UNIT_KBIT; |
c6c8fea2 | 47 | char *slash_ptr, *tmp_ptr; |
0b8336f5 | 48 | u64 ldown, lup; |
414254e3 | 49 | int ret; |
c6c8fea2 SE |
50 | |
51 | slash_ptr = strchr(buff, '/'); | |
52 | if (slash_ptr) | |
53 | *slash_ptr = 0; | |
54 | ||
55 | if (strlen(buff) > 4) { | |
56 | tmp_ptr = buff + strlen(buff) - 4; | |
57 | ||
b7a8d756 | 58 | if (strncasecmp(tmp_ptr, "mbit", 4) == 0) |
414254e3 | 59 | bw_unit_type = BATADV_BW_UNIT_MBIT; |
c6c8fea2 | 60 | |
b7a8d756 | 61 | if ((strncasecmp(tmp_ptr, "kbit", 4) == 0) || |
414254e3 | 62 | (bw_unit_type == BATADV_BW_UNIT_MBIT)) |
c6c8fea2 SE |
63 | *tmp_ptr = '\0'; |
64 | } | |
65 | ||
0b8336f5 | 66 | ret = kstrtou64(buff, 10, &ldown); |
c6c8fea2 | 67 | if (ret) { |
3e34819e SE |
68 | batadv_err(net_dev, |
69 | "Download speed of gateway mode invalid: %s\n", | |
70 | buff); | |
c6c8fea2 SE |
71 | return false; |
72 | } | |
73 | ||
414254e3 ML |
74 | switch (bw_unit_type) { |
75 | case BATADV_BW_UNIT_MBIT: | |
0b8336f5 SE |
76 | /* prevent overflow */ |
77 | if (U64_MAX / 10 < ldown) { | |
78 | batadv_err(net_dev, | |
79 | "Download speed of gateway mode too large: %s\n", | |
80 | buff); | |
81 | return false; | |
82 | } | |
83 | ||
84 | ldown *= 10; | |
414254e3 ML |
85 | break; |
86 | case BATADV_BW_UNIT_KBIT: | |
87 | default: | |
0b8336f5 | 88 | ldown = div_u64(ldown, 100); |
414254e3 ML |
89 | break; |
90 | } | |
c6c8fea2 | 91 | |
0b8336f5 SE |
92 | if (U32_MAX < ldown) { |
93 | batadv_err(net_dev, | |
94 | "Download speed of gateway mode too large: %s\n", | |
95 | buff); | |
96 | return false; | |
97 | } | |
98 | ||
99 | *down = ldown; | |
100 | ||
c6c8fea2 SE |
101 | /* we also got some upload info */ |
102 | if (slash_ptr) { | |
414254e3 | 103 | bw_unit_type = BATADV_BW_UNIT_KBIT; |
c6c8fea2 SE |
104 | |
105 | if (strlen(slash_ptr + 1) > 4) { | |
106 | tmp_ptr = slash_ptr + 1 - 4 + strlen(slash_ptr + 1); | |
107 | ||
b7a8d756 | 108 | if (strncasecmp(tmp_ptr, "mbit", 4) == 0) |
414254e3 | 109 | bw_unit_type = BATADV_BW_UNIT_MBIT; |
c6c8fea2 | 110 | |
b7a8d756 | 111 | if ((strncasecmp(tmp_ptr, "kbit", 4) == 0) || |
414254e3 | 112 | (bw_unit_type == BATADV_BW_UNIT_MBIT)) |
c6c8fea2 SE |
113 | *tmp_ptr = '\0'; |
114 | } | |
115 | ||
0b8336f5 | 116 | ret = kstrtou64(slash_ptr + 1, 10, &lup); |
c6c8fea2 | 117 | if (ret) { |
3e34819e SE |
118 | batadv_err(net_dev, |
119 | "Upload speed of gateway mode invalid: %s\n", | |
120 | slash_ptr + 1); | |
c6c8fea2 SE |
121 | return false; |
122 | } | |
123 | ||
414254e3 ML |
124 | switch (bw_unit_type) { |
125 | case BATADV_BW_UNIT_MBIT: | |
0b8336f5 SE |
126 | /* prevent overflow */ |
127 | if (U64_MAX / 10 < lup) { | |
128 | batadv_err(net_dev, | |
129 | "Upload speed of gateway mode too large: %s\n", | |
130 | slash_ptr + 1); | |
131 | return false; | |
132 | } | |
133 | ||
134 | lup *= 10; | |
414254e3 ML |
135 | break; |
136 | case BATADV_BW_UNIT_KBIT: | |
137 | default: | |
0b8336f5 | 138 | lup = div_u64(lup, 100); |
414254e3 ML |
139 | break; |
140 | } | |
0b8336f5 SE |
141 | |
142 | if (U32_MAX < lup) { | |
143 | batadv_err(net_dev, | |
144 | "Upload speed of gateway mode too large: %s\n", | |
145 | slash_ptr + 1); | |
146 | return false; | |
147 | } | |
148 | ||
149 | *up = lup; | |
c6c8fea2 SE |
150 | } |
151 | ||
152 | return true; | |
153 | } | |
154 | ||
414254e3 ML |
155 | /** |
156 | * batadv_gw_tvlv_container_update - update the gw tvlv container after gateway | |
157 | * setting change | |
158 | * @bat_priv: the bat priv with all the soft interface information | |
159 | */ | |
160 | void batadv_gw_tvlv_container_update(struct batadv_priv *bat_priv) | |
161 | { | |
162 | struct batadv_tvlv_gateway_data gw; | |
6b5e971a | 163 | u32 down, up; |
414254e3 ML |
164 | char gw_mode; |
165 | ||
166 | gw_mode = atomic_read(&bat_priv->gw_mode); | |
167 | ||
168 | switch (gw_mode) { | |
169 | case BATADV_GW_MODE_OFF: | |
170 | case BATADV_GW_MODE_CLIENT: | |
171 | batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1); | |
172 | break; | |
173 | case BATADV_GW_MODE_SERVER: | |
174 | down = atomic_read(&bat_priv->gw.bandwidth_down); | |
175 | up = atomic_read(&bat_priv->gw.bandwidth_up); | |
176 | gw.bandwidth_down = htonl(down); | |
177 | gw.bandwidth_up = htonl(up); | |
178 | batadv_tvlv_container_register(bat_priv, BATADV_TVLV_GW, 1, | |
179 | &gw, sizeof(gw)); | |
180 | break; | |
181 | } | |
182 | } | |
183 | ||
84d5e5e0 SE |
184 | ssize_t batadv_gw_bandwidth_set(struct net_device *net_dev, char *buff, |
185 | size_t count) | |
c6c8fea2 | 186 | { |
56303d34 | 187 | struct batadv_priv *bat_priv = netdev_priv(net_dev); |
4f248cff SE |
188 | u32 down_curr; |
189 | u32 up_curr; | |
190 | u32 down_new = 0; | |
191 | u32 up_new = 0; | |
c6c8fea2 SE |
192 | bool ret; |
193 | ||
414254e3 ML |
194 | down_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_down); |
195 | up_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_up); | |
196 | ||
197 | ret = batadv_parse_gw_bandwidth(net_dev, buff, &down_new, &up_new); | |
c6c8fea2 | 198 | if (!ret) |
77927b7d | 199 | return -EINVAL; |
c6c8fea2 | 200 | |
414254e3 ML |
201 | if (!down_new) |
202 | down_new = 1; | |
c6c8fea2 | 203 | |
414254e3 ML |
204 | if (!up_new) |
205 | up_new = down_new / 5; | |
c6c8fea2 | 206 | |
414254e3 ML |
207 | if (!up_new) |
208 | up_new = 1; | |
c6c8fea2 | 209 | |
414254e3 | 210 | if ((down_curr == down_new) && (up_curr == up_new)) |
dafe94b2 ML |
211 | return count; |
212 | ||
4e820e72 | 213 | batadv_gw_reselect(bat_priv); |
3e34819e | 214 | batadv_info(net_dev, |
414254e3 ML |
215 | "Changing gateway bandwidth from: '%u.%u/%u.%u MBit' to: '%u.%u/%u.%u MBit'\n", |
216 | down_curr / 10, down_curr % 10, up_curr / 10, up_curr % 10, | |
217 | down_new / 10, down_new % 10, up_new / 10, up_new % 10); | |
c6c8fea2 | 218 | |
414254e3 ML |
219 | atomic_set(&bat_priv->gw.bandwidth_down, down_new); |
220 | atomic_set(&bat_priv->gw.bandwidth_up, up_new); | |
221 | batadv_gw_tvlv_container_update(bat_priv); | |
c6c8fea2 | 222 | |
c6c8fea2 SE |
223 | return count; |
224 | } | |
414254e3 ML |
225 | |
226 | /** | |
227 | * batadv_gw_tvlv_ogm_handler_v1 - process incoming gateway tvlv container | |
228 | * @bat_priv: the bat priv with all the soft interface information | |
229 | * @orig: the orig_node of the ogm | |
230 | * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags) | |
231 | * @tvlv_value: tvlv buffer containing the gateway data | |
232 | * @tvlv_value_len: tvlv buffer length | |
233 | */ | |
234 | static void batadv_gw_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, | |
235 | struct batadv_orig_node *orig, | |
6b5e971a SE |
236 | u8 flags, |
237 | void *tvlv_value, u16 tvlv_value_len) | |
414254e3 ML |
238 | { |
239 | struct batadv_tvlv_gateway_data gateway, *gateway_ptr; | |
240 | ||
241 | /* only fetch the tvlv value if the handler wasn't called via the | |
242 | * CIFNOTFND flag and if there is data to fetch | |
243 | */ | |
244 | if ((flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) || | |
245 | (tvlv_value_len < sizeof(gateway))) { | |
246 | gateway.bandwidth_down = 0; | |
247 | gateway.bandwidth_up = 0; | |
248 | } else { | |
249 | gateway_ptr = tvlv_value; | |
250 | gateway.bandwidth_down = gateway_ptr->bandwidth_down; | |
251 | gateway.bandwidth_up = gateway_ptr->bandwidth_up; | |
252 | if ((gateway.bandwidth_down == 0) || | |
253 | (gateway.bandwidth_up == 0)) { | |
254 | gateway.bandwidth_down = 0; | |
255 | gateway.bandwidth_up = 0; | |
256 | } | |
257 | } | |
258 | ||
259 | batadv_gw_node_update(bat_priv, orig, &gateway); | |
260 | ||
261 | /* restart gateway selection if fast or late switching was enabled */ | |
262 | if ((gateway.bandwidth_down != 0) && | |
263 | (atomic_read(&bat_priv->gw_mode) == BATADV_GW_MODE_CLIENT) && | |
264 | (atomic_read(&bat_priv->gw_sel_class) > 2)) | |
265 | batadv_gw_check_election(bat_priv, orig); | |
266 | } | |
267 | ||
268 | /** | |
269 | * batadv_gw_init - initialise the gateway handling internals | |
270 | * @bat_priv: the bat priv with all the soft interface information | |
271 | */ | |
272 | void batadv_gw_init(struct batadv_priv *bat_priv) | |
273 | { | |
274 | batadv_tvlv_handler_register(bat_priv, batadv_gw_tvlv_ogm_handler_v1, | |
275 | NULL, BATADV_TVLV_GW, 1, | |
276 | BATADV_TVLV_HANDLER_OGM_CIFNOTFND); | |
277 | } | |
278 | ||
279 | /** | |
280 | * batadv_gw_free - free the gateway handling internals | |
281 | * @bat_priv: the bat priv with all the soft interface information | |
282 | */ | |
283 | void batadv_gw_free(struct batadv_priv *bat_priv) | |
284 | { | |
285 | batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1); | |
286 | batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_GW, 1); | |
287 | } |