1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include "core.h"
38#include "node.h"
39#include "discover.h"
40
41
42#define TIPC_LINK_REQ_INIT msecs_to_jiffies(125)
43
44#define TIPC_LINK_REQ_FAST msecs_to_jiffies(1000)
45
46#define TIPC_LINK_REQ_SLOW msecs_to_jiffies(60000)
47
48#define TIPC_LINK_REQ_INACTIVE 0xffffffff
49
50
51
52
53
54
55
56
57
58
59
60
61
62struct tipc_link_req {
63 u32 bearer_id;
64 struct tipc_media_addr dest;
65 struct net *net;
66 u32 domain;
67 int num_nodes;
68 spinlock_t lock;
69 struct sk_buff *buf;
70 struct timer_list timer;
71 unsigned long timer_intv;
72};
73
74
75
76
77
78
79
80static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
81 struct tipc_bearer *b)
82{
83 struct tipc_net *tn = net_generic(net, tipc_net_id);
84 struct tipc_msg *msg;
85 u32 dest_domain = b->domain;
86
87 msg = buf_msg(buf);
88 tipc_msg_init(tn->own_addr, msg, LINK_CONFIG, type,
89 MAX_H_SIZE, dest_domain);
90 msg_set_non_seq(msg, 1);
91 msg_set_node_sig(msg, tn->random);
92 msg_set_node_capabilities(msg, TIPC_NODE_CAPABILITIES);
93 msg_set_dest_domain(msg, dest_domain);
94 msg_set_bc_netid(msg, tn->net_id);
95 b->media->addr2msg(msg_media_addr(msg), &b->addr);
96}
97
98
99
100
101
102
103
104static void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr,
105 struct tipc_media_addr *media_addr)
106{
107 char node_addr_str[16];
108 char media_addr_str[64];
109
110 tipc_addr_string_fill(node_addr_str, node_addr);
111 tipc_media_addr_printf(media_addr_str, sizeof(media_addr_str),
112 media_addr);
113 pr_warn("Duplicate %s using %s seen on <%s>\n", node_addr_str,
114 media_addr_str, b->name);
115}
116
117
118
119
120
121
122
123void tipc_disc_rcv(struct net *net, struct sk_buff *skb,
124 struct tipc_bearer *bearer)
125{
126 struct tipc_net *tn = net_generic(net, tipc_net_id);
127 struct tipc_media_addr maddr;
128 struct sk_buff *rskb;
129 struct tipc_msg *hdr = buf_msg(skb);
130 u32 ddom = msg_dest_domain(hdr);
131 u32 onode = msg_prevnode(hdr);
132 u32 net_id = msg_bc_netid(hdr);
133 u32 mtyp = msg_type(hdr);
134 u32 signature = msg_node_sig(hdr);
135 u16 caps = msg_node_capabilities(hdr);
136 bool respond = false;
137 bool dupl_addr = false;
138
139 bearer->media->msg2addr(bearer, &maddr, msg_media_addr(hdr));
140 kfree_skb(skb);
141
142
143 if (net_id != tn->net_id)
144 return;
145 if (maddr.broadcast)
146 return;
147 if (!tipc_addr_domain_valid(ddom))
148 return;
149 if (!tipc_addr_node_valid(onode))
150 return;
151
152 if (in_own_node(net, onode)) {
153 if (memcmp(&maddr, &bearer->addr, sizeof(maddr)))
154 disc_dupl_alert(bearer, tn->own_addr, &maddr);
155 return;
156 }
157 if (!tipc_in_scope(ddom, tn->own_addr))
158 return;
159 if (!tipc_in_scope(bearer->domain, onode))
160 return;
161
162 tipc_node_check_dest(net, onode, bearer, caps, signature,
163 &maddr, &respond, &dupl_addr);
164 if (dupl_addr)
165 disc_dupl_alert(bearer, onode, &maddr);
166
167
168 if (respond && (mtyp == DSC_REQ_MSG)) {
169 rskb = tipc_buf_acquire(MAX_H_SIZE);
170 if (!rskb)
171 return;
172 tipc_disc_init_msg(net, rskb, DSC_RESP_MSG, bearer);
173 tipc_bearer_xmit_skb(net, bearer->identity, rskb, &maddr);
174 }
175}
176
177
178
179
180
181
182
183
184static void disc_update(struct tipc_link_req *req)
185{
186 if (!req->num_nodes) {
187 if ((req->timer_intv == TIPC_LINK_REQ_INACTIVE) ||
188 (req->timer_intv > TIPC_LINK_REQ_FAST)) {
189 req->timer_intv = TIPC_LINK_REQ_INIT;
190 mod_timer(&req->timer, jiffies + req->timer_intv);
191 }
192 }
193}
194
195
196
197
198
199void tipc_disc_add_dest(struct tipc_link_req *req)
200{
201 spin_lock_bh(&req->lock);
202 req->num_nodes++;
203 spin_unlock_bh(&req->lock);
204}
205
206
207
208
209
210void tipc_disc_remove_dest(struct tipc_link_req *req)
211{
212 spin_lock_bh(&req->lock);
213 req->num_nodes--;
214 disc_update(req);
215 spin_unlock_bh(&req->lock);
216}
217
218
219
220
221
222
223
224static void disc_timeout(unsigned long data)
225{
226 struct tipc_link_req *req = (struct tipc_link_req *)data;
227 struct sk_buff *skb;
228 int max_delay;
229
230 spin_lock_bh(&req->lock);
231
232
233 if (tipc_node(req->domain) && req->num_nodes) {
234 req->timer_intv = TIPC_LINK_REQ_INACTIVE;
235 goto exit;
236 }
237
238
239
240
241
242
243
244
245 skb = skb_clone(req->buf, GFP_ATOMIC);
246 if (skb)
247 tipc_bearer_xmit_skb(req->net, req->bearer_id, skb, &req->dest);
248 req->timer_intv *= 2;
249 if (req->num_nodes)
250 max_delay = TIPC_LINK_REQ_SLOW;
251 else
252 max_delay = TIPC_LINK_REQ_FAST;
253 if (req->timer_intv > max_delay)
254 req->timer_intv = max_delay;
255
256 mod_timer(&req->timer, jiffies + req->timer_intv);
257exit:
258 spin_unlock_bh(&req->lock);
259}
260
261
262
263
264
265
266
267
268
269
270int tipc_disc_create(struct net *net, struct tipc_bearer *b,
271 struct tipc_media_addr *dest)
272{
273 struct tipc_link_req *req;
274 struct sk_buff *skb;
275
276 req = kmalloc(sizeof(*req), GFP_ATOMIC);
277 if (!req)
278 return -ENOMEM;
279 req->buf = tipc_buf_acquire(MAX_H_SIZE);
280 if (!req->buf) {
281 kfree(req);
282 return -ENOMEM;
283 }
284
285 tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
286 memcpy(&req->dest, dest, sizeof(*dest));
287 req->net = net;
288 req->bearer_id = b->identity;
289 req->domain = b->domain;
290 req->num_nodes = 0;
291 req->timer_intv = TIPC_LINK_REQ_INIT;
292 spin_lock_init(&req->lock);
293 setup_timer(&req->timer, disc_timeout, (unsigned long)req);
294 mod_timer(&req->timer, jiffies + req->timer_intv);
295 b->link_req = req;
296 skb = skb_clone(req->buf, GFP_ATOMIC);
297 if (skb)
298 tipc_bearer_xmit_skb(net, req->bearer_id, skb, &req->dest);
299 return 0;
300}
301
302
303
304
305
306void tipc_disc_delete(struct tipc_link_req *req)
307{
308 del_timer_sync(&req->timer);
309 kfree_skb(req->buf);
310 kfree(req);
311}
312
313
314
315
316
317
318
319void tipc_disc_reset(struct net *net, struct tipc_bearer *b)
320{
321 struct tipc_link_req *req = b->link_req;
322 struct sk_buff *skb;
323
324 spin_lock_bh(&req->lock);
325 tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
326 req->net = net;
327 req->bearer_id = b->identity;
328 req->domain = b->domain;
329 req->num_nodes = 0;
330 req->timer_intv = TIPC_LINK_REQ_INIT;
331 mod_timer(&req->timer, jiffies + req->timer_intv);
332 skb = skb_clone(req->buf, GFP_ATOMIC);
333 if (skb)
334 tipc_bearer_xmit_skb(net, req->bearer_id, skb, &req->dest);
335 spin_unlock_bh(&req->lock);
336}
337