1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "gateway_common.h"
19#include "main.h"
20
21#include <linux/atomic.h>
22#include <linux/byteorder/generic.h>
23#include <linux/errno.h>
24#include <linux/kernel.h>
25#include <linux/math64.h>
26#include <linux/netdevice.h>
27#include <linux/stddef.h>
28#include <linux/string.h>
29
30#include "gateway_client.h"
31#include "log.h"
32#include "packet.h"
33#include "tvlv.h"
34
35
36
37
38
39
40
41
42
43
44
45bool batadv_parse_throughput(struct net_device *net_dev, char *buff,
46 const char *description, u32 *throughput)
47{
48 enum batadv_bandwidth_units bw_unit_type = BATADV_BW_UNIT_KBIT;
49 u64 lthroughput;
50 char *tmp_ptr;
51 int ret;
52
53 if (strlen(buff) > 4) {
54 tmp_ptr = buff + strlen(buff) - 4;
55
56 if (strncasecmp(tmp_ptr, "mbit", 4) == 0)
57 bw_unit_type = BATADV_BW_UNIT_MBIT;
58
59 if ((strncasecmp(tmp_ptr, "kbit", 4) == 0) ||
60 (bw_unit_type == BATADV_BW_UNIT_MBIT))
61 *tmp_ptr = '\0';
62 }
63
64 ret = kstrtou64(buff, 10, <hroughput);
65 if (ret) {
66 batadv_err(net_dev,
67 "Invalid throughput speed for %s: %s\n",
68 description, buff);
69 return false;
70 }
71
72 switch (bw_unit_type) {
73 case BATADV_BW_UNIT_MBIT:
74
75 if (U64_MAX / 10 < lthroughput) {
76 batadv_err(net_dev,
77 "Throughput speed for %s too large: %s\n",
78 description, buff);
79 return false;
80 }
81
82 lthroughput *= 10;
83 break;
84 case BATADV_BW_UNIT_KBIT:
85 default:
86 lthroughput = div_u64(lthroughput, 100);
87 break;
88 }
89
90 if (lthroughput > U32_MAX) {
91 batadv_err(net_dev,
92 "Throughput speed for %s too large: %s\n",
93 description, buff);
94 return false;
95 }
96
97 *throughput = lthroughput;
98
99 return true;
100}
101
102
103
104
105
106
107
108
109
110
111
112static bool batadv_parse_gw_bandwidth(struct net_device *net_dev, char *buff,
113 u32 *down, u32 *up)
114{
115 char *slash_ptr;
116 bool ret;
117
118 slash_ptr = strchr(buff, '/');
119 if (slash_ptr)
120 *slash_ptr = 0;
121
122 ret = batadv_parse_throughput(net_dev, buff, "download gateway speed",
123 down);
124 if (!ret)
125 return false;
126
127
128 if (slash_ptr) {
129 ret = batadv_parse_throughput(net_dev, slash_ptr + 1,
130 "upload gateway speed", up);
131 if (!ret)
132 return false;
133 }
134
135 return true;
136}
137
138
139
140
141
142
143void batadv_gw_tvlv_container_update(struct batadv_priv *bat_priv)
144{
145 struct batadv_tvlv_gateway_data gw;
146 u32 down, up;
147 char gw_mode;
148
149 gw_mode = atomic_read(&bat_priv->gw.mode);
150
151 switch (gw_mode) {
152 case BATADV_GW_MODE_OFF:
153 case BATADV_GW_MODE_CLIENT:
154 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1);
155 break;
156 case BATADV_GW_MODE_SERVER:
157 down = atomic_read(&bat_priv->gw.bandwidth_down);
158 up = atomic_read(&bat_priv->gw.bandwidth_up);
159 gw.bandwidth_down = htonl(down);
160 gw.bandwidth_up = htonl(up);
161 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_GW, 1,
162 &gw, sizeof(gw));
163 break;
164 }
165}
166
167ssize_t batadv_gw_bandwidth_set(struct net_device *net_dev, char *buff,
168 size_t count)
169{
170 struct batadv_priv *bat_priv = netdev_priv(net_dev);
171 u32 down_curr;
172 u32 up_curr;
173 u32 down_new = 0;
174 u32 up_new = 0;
175 bool ret;
176
177 down_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_down);
178 up_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_up);
179
180 ret = batadv_parse_gw_bandwidth(net_dev, buff, &down_new, &up_new);
181 if (!ret)
182 return -EINVAL;
183
184 if (!down_new)
185 down_new = 1;
186
187 if (!up_new)
188 up_new = down_new / 5;
189
190 if (!up_new)
191 up_new = 1;
192
193 if ((down_curr == down_new) && (up_curr == up_new))
194 return count;
195
196 batadv_gw_reselect(bat_priv);
197 batadv_info(net_dev,
198 "Changing gateway bandwidth from: '%u.%u/%u.%u MBit' to: '%u.%u/%u.%u MBit'\n",
199 down_curr / 10, down_curr % 10, up_curr / 10, up_curr % 10,
200 down_new / 10, down_new % 10, up_new / 10, up_new % 10);
201
202 atomic_set(&bat_priv->gw.bandwidth_down, down_new);
203 atomic_set(&bat_priv->gw.bandwidth_up, up_new);
204 batadv_gw_tvlv_container_update(bat_priv);
205
206 return count;
207}
208
209
210
211
212
213
214
215
216
217static void batadv_gw_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
218 struct batadv_orig_node *orig,
219 u8 flags,
220 void *tvlv_value, u16 tvlv_value_len)
221{
222 struct batadv_tvlv_gateway_data gateway, *gateway_ptr;
223
224
225
226
227 if ((flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) ||
228 (tvlv_value_len < sizeof(gateway))) {
229 gateway.bandwidth_down = 0;
230 gateway.bandwidth_up = 0;
231 } else {
232 gateway_ptr = tvlv_value;
233 gateway.bandwidth_down = gateway_ptr->bandwidth_down;
234 gateway.bandwidth_up = gateway_ptr->bandwidth_up;
235 if ((gateway.bandwidth_down == 0) ||
236 (gateway.bandwidth_up == 0)) {
237 gateway.bandwidth_down = 0;
238 gateway.bandwidth_up = 0;
239 }
240 }
241
242 batadv_gw_node_update(bat_priv, orig, &gateway);
243
244
245 if ((gateway.bandwidth_down != 0) &&
246 (atomic_read(&bat_priv->gw.mode) == BATADV_GW_MODE_CLIENT) &&
247 (atomic_read(&bat_priv->gw.sel_class) > 2))
248 batadv_gw_check_election(bat_priv, orig);
249}
250
251
252
253
254
255void batadv_gw_init(struct batadv_priv *bat_priv)
256{
257 batadv_tvlv_handler_register(bat_priv, batadv_gw_tvlv_ogm_handler_v1,
258 NULL, BATADV_TVLV_GW, 1,
259 BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
260}
261
262
263
264
265
266void batadv_gw_free(struct batadv_priv *bat_priv)
267{
268 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1);
269 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_GW, 1);
270}
271