tipc: Fix issues with fragmentation of an existing message buffer
[linux-2.6.git] / net / tipc / discover.c
1 /*
2  * net/tipc/discover.c
3  *
4  * Copyright (c) 2003-2006, Ericsson AB
5  * Copyright (c) 2005-2006, 2010-2011, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the names of the copyright holders nor the names of its
17  *    contributors may be used to endorse or promote products derived from
18  *    this software without specific prior written permission.
19  *
20  * Alternatively, this software may be distributed under the terms of the
21  * GNU General Public License ("GPL") version 2 as published by the Free
22  * Software Foundation.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 #include "core.h"
38 #include "link.h"
39 #include "discover.h"
40
41 #define TIPC_LINK_REQ_INIT      125     /* min delay during bearer start up */
42 #define TIPC_LINK_REQ_FAST      2000    /* normal delay if bearer has no links */
43 #define TIPC_LINK_REQ_SLOW      600000  /* normal delay if bearer has links */
44
45 /*
46  * TODO: Most of the inter-cluster setup stuff should be
47  * rewritten, and be made conformant with specification.
48  */
49
50
51 /**
52  * struct link_req - information about an ongoing link setup request
53  * @bearer: bearer issuing requests
54  * @dest: destination address for request messages
55  * @buf: request message to be (repeatedly) sent
56  * @timer: timer governing period between requests
57  * @timer_intv: current interval between requests (in ms)
58  */
59 struct link_req {
60         struct tipc_bearer *bearer;
61         struct tipc_media_addr dest;
62         struct sk_buff *buf;
63         struct timer_list timer;
64         unsigned int timer_intv;
65 };
66
67 /**
68  * tipc_disc_init_msg - initialize a link setup message
69  * @type: message type (request or response)
70  * @dest_domain: network domain of node(s) which should respond to message
71  * @b_ptr: ptr to bearer issuing message
72  */
73
74 static struct sk_buff *tipc_disc_init_msg(u32 type,
75                                           u32 dest_domain,
76                                           struct tipc_bearer *b_ptr)
77 {
78         struct sk_buff *buf = tipc_buf_acquire(INT_H_SIZE);
79         struct tipc_msg *msg;
80
81         if (buf) {
82                 msg = buf_msg(buf);
83                 tipc_msg_init(msg, LINK_CONFIG, type, INT_H_SIZE, dest_domain);
84                 msg_set_non_seq(msg, 1);
85                 msg_set_dest_domain(msg, dest_domain);
86                 msg_set_bc_netid(msg, tipc_net_id);
87                 msg_set_media_addr(msg, &b_ptr->addr);
88         }
89         return buf;
90 }
91
92 /**
93  * disc_dupl_alert - issue node address duplication alert
94  * @b_ptr: pointer to bearer detecting duplication
95  * @node_addr: duplicated node address
96  * @media_addr: media address advertised by duplicated node
97  */
98
99 static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr,
100                             struct tipc_media_addr *media_addr)
101 {
102         char node_addr_str[16];
103         char media_addr_str[64];
104         struct print_buf pb;
105
106         tipc_addr_string_fill(node_addr_str, node_addr);
107         tipc_printbuf_init(&pb, media_addr_str, sizeof(media_addr_str));
108         tipc_media_addr_printf(&pb, media_addr);
109         tipc_printbuf_validate(&pb);
110         warn("Duplicate %s using %s seen on <%s>\n",
111              node_addr_str, media_addr_str, b_ptr->name);
112 }
113
114 /**
115  * tipc_disc_recv_msg - handle incoming link setup message (request or response)
116  * @buf: buffer containing message
117  * @b_ptr: bearer that message arrived on
118  */
119
120 void tipc_disc_recv_msg(struct sk_buff *buf, struct tipc_bearer *b_ptr)
121 {
122         struct tipc_node *n_ptr;
123         struct link *link;
124         struct tipc_media_addr media_addr, *addr;
125         struct sk_buff *rbuf;
126         struct tipc_msg *msg = buf_msg(buf);
127         u32 dest = msg_dest_domain(msg);
128         u32 orig = msg_prevnode(msg);
129         u32 net_id = msg_bc_netid(msg);
130         u32 type = msg_type(msg);
131         int link_fully_up;
132
133         msg_get_media_addr(msg, &media_addr);
134         buf_discard(buf);
135
136         /* Validate discovery message from requesting node */
137         if (net_id != tipc_net_id)
138                 return;
139         if (!tipc_addr_domain_valid(dest))
140                 return;
141         if (!tipc_addr_node_valid(orig))
142                 return;
143         if (orig == tipc_own_addr) {
144                 if (memcmp(&media_addr, &b_ptr->addr, sizeof(media_addr)))
145                         disc_dupl_alert(b_ptr, tipc_own_addr, &media_addr);
146                 return;
147         }
148         if (!tipc_in_scope(dest, tipc_own_addr))
149                 return;
150         if (!in_own_cluster(orig))
151                 return;
152
153         /* Locate structure corresponding to requesting node */
154         n_ptr = tipc_node_find(orig);
155         if (!n_ptr) {
156                 n_ptr = tipc_node_create(orig);
157                 if (!n_ptr)
158                         return;
159         }
160         tipc_node_lock(n_ptr);
161
162         /* Don't talk to neighbor during cleanup after last session */
163         if (n_ptr->cleanup_required) {
164                 tipc_node_unlock(n_ptr);
165                 return;
166         }
167
168         link = n_ptr->links[b_ptr->identity];
169
170         /* Create a link endpoint for this bearer, if necessary */
171         if (!link) {
172                 link = tipc_link_create(n_ptr, b_ptr, &media_addr);
173                 if (!link) {
174                         tipc_node_unlock(n_ptr);
175                         return;
176                 }
177         }
178
179         /*
180          * Ensure requesting node's media address is correct
181          *
182          * If media address doesn't match and the link is working, reject the
183          * request (must be from a duplicate node).
184          *
185          * If media address doesn't match and the link is not working, accept
186          * the new media address and reset the link to ensure it starts up
187          * cleanly.
188          */
189         addr = &link->media_addr;
190         if (memcmp(addr, &media_addr, sizeof(*addr))) {
191                 if (tipc_link_is_up(link) || (!link->started)) {
192                         disc_dupl_alert(b_ptr, orig, &media_addr);
193                         tipc_node_unlock(n_ptr);
194                         return;
195                 }
196                 warn("Resetting link <%s>, peer interface address changed\n",
197                      link->name);
198                 memcpy(addr, &media_addr, sizeof(*addr));
199                 tipc_link_reset(link);
200         }
201
202         /* Accept discovery message & send response, if necessary */
203         link_fully_up = link_working_working(link);
204
205         if ((type == DSC_REQ_MSG) && !link_fully_up && !b_ptr->blocked) {
206                 rbuf = tipc_disc_init_msg(DSC_RESP_MSG, orig, b_ptr);
207                 if (rbuf) {
208                         b_ptr->media->send_msg(rbuf, b_ptr, &media_addr);
209                         buf_discard(rbuf);
210                 }
211         }
212
213         tipc_node_unlock(n_ptr);
214 }
215
216 /**
217  * tipc_disc_stop_link_req - stop sending periodic link setup requests
218  * @req: ptr to link request structure
219  */
220
221 void tipc_disc_stop_link_req(struct link_req *req)
222 {
223         if (!req)
224                 return;
225
226         k_cancel_timer(&req->timer);
227         k_term_timer(&req->timer);
228         buf_discard(req->buf);
229         kfree(req);
230 }
231
232 /**
233  * tipc_disc_update_link_req - update frequency of periodic link setup requests
234  * @req: ptr to link request structure
235  */
236
237 void tipc_disc_update_link_req(struct link_req *req)
238 {
239         if (!req)
240                 return;
241
242         if (req->timer_intv == TIPC_LINK_REQ_SLOW) {
243                 if (!req->bearer->nodes.count) {
244                         req->timer_intv = TIPC_LINK_REQ_FAST;
245                         k_start_timer(&req->timer, req->timer_intv);
246                 }
247         } else if (req->timer_intv == TIPC_LINK_REQ_FAST) {
248                 if (req->bearer->nodes.count) {
249                         req->timer_intv = TIPC_LINK_REQ_SLOW;
250                         k_start_timer(&req->timer, req->timer_intv);
251                 }
252         } else {
253                 /* leave timer "as is" if haven't yet reached a "normal" rate */
254         }
255 }
256
257 /**
258  * disc_timeout - send a periodic link setup request
259  * @req: ptr to link request structure
260  *
261  * Called whenever a link setup request timer associated with a bearer expires.
262  */
263
264 static void disc_timeout(struct link_req *req)
265 {
266         spin_lock_bh(&req->bearer->lock);
267
268         req->bearer->media->send_msg(req->buf, req->bearer, &req->dest);
269
270         if ((req->timer_intv == TIPC_LINK_REQ_SLOW) ||
271             (req->timer_intv == TIPC_LINK_REQ_FAST)) {
272                 /* leave timer interval "as is" if already at a "normal" rate */
273         } else {
274                 req->timer_intv *= 2;
275                 if (req->timer_intv > TIPC_LINK_REQ_FAST)
276                         req->timer_intv = TIPC_LINK_REQ_FAST;
277                 if ((req->timer_intv == TIPC_LINK_REQ_FAST) &&
278                     (req->bearer->nodes.count))
279                         req->timer_intv = TIPC_LINK_REQ_SLOW;
280         }
281         k_start_timer(&req->timer, req->timer_intv);
282
283         spin_unlock_bh(&req->bearer->lock);
284 }
285
286 /**
287  * tipc_disc_init_link_req - start sending periodic link setup requests
288  * @b_ptr: ptr to bearer issuing requests
289  * @dest: destination address for request messages
290  * @dest_domain: network domain of node(s) which should respond to message
291  *
292  * Returns pointer to link request structure, or NULL if unable to create.
293  */
294
295 struct link_req *tipc_disc_init_link_req(struct tipc_bearer *b_ptr,
296                                          const struct tipc_media_addr *dest,
297                                          u32 dest_domain)
298 {
299         struct link_req *req;
300
301         req = kmalloc(sizeof(*req), GFP_ATOMIC);
302         if (!req)
303                 return NULL;
304
305         req->buf = tipc_disc_init_msg(DSC_REQ_MSG, dest_domain, b_ptr);
306         if (!req->buf) {
307                 kfree(req);
308                 return NULL;
309         }
310
311         memcpy(&req->dest, dest, sizeof(*dest));
312         req->bearer = b_ptr;
313         req->timer_intv = TIPC_LINK_REQ_INIT;
314         k_init_timer(&req->timer, (Handler)disc_timeout, (unsigned long)req);
315         k_start_timer(&req->timer, req->timer_intv);
316         return req;
317 }
318