blob: c3e96e8154188af27c0d5fc545fe95c54a29e9e9 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
2 * net/tipc/msg.c: TIPC message header routines
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Jon Paul Maloycf2157f2015-03-13 16:08:06 -04004 * Copyright (c) 2000-2006, 2014-2015, Ericsson AB
Allan Stephens741de3e2011-01-25 13:33:31 -05005 * Copyright (c) 2005, 2010-2011, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01006 * All rights reserved.
7 *
Per Liden9ea1fd32006-01-11 13:30:43 +01008 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +01009 * modification, are permitted provided that the following conditions are met:
10 *
Per Liden9ea1fd32006-01-11 13:30:43 +010011 * 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.
Per Lidenb97bf3f2006-01-02 19:04:38 +010019 *
Per Liden9ea1fd32006-01-11 13:30:43 +010020 * 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
Per Lidenb97bf3f2006-01-02 19:04:38 +010034 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
Ying Xuec93d3ba2015-01-09 15:27:04 +080037#include <net/sock.h>
Per Lidenb97bf3f2006-01-02 19:04:38 +010038#include "core.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010039#include "msg.h"
Jon Paul Maloy5a379072014-06-25 20:41:36 -050040#include "addr.h"
41#include "name_table.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010042
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -050043#define MAX_FORWARD_SIZE 1024
44
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050045static unsigned int align(unsigned int i)
Allan Stephens23461e82010-05-11 14:30:18 +000046{
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050047 return (i + 3) & ~3u;
Allan Stephens23461e82010-05-11 14:30:18 +000048}
49
Ying Xue859fc7c2015-01-09 15:27:01 +080050/**
51 * tipc_buf_acquire - creates a TIPC message buffer
52 * @size: message size (including TIPC header)
53 *
54 * Returns a new buffer with data pointers set to the specified size.
55 *
56 * NOTE: Headroom is reserved to allow prepending of a data link header.
57 * There may also be unrequested tailroom present at the buffer's end.
58 */
59struct sk_buff *tipc_buf_acquire(u32 size)
60{
61 struct sk_buff *skb;
62 unsigned int buf_size = (BUF_HEADROOM + size + 3) & ~3u;
63
64 skb = alloc_skb_fclone(buf_size, GFP_ATOMIC);
65 if (skb) {
66 skb_reserve(skb, BUF_HEADROOM);
67 skb_put(skb, size);
68 skb->next = NULL;
69 }
70 return skb;
71}
72
Jon Paul Maloyc5898632015-02-05 08:36:36 -050073void tipc_msg_init(u32 own_node, struct tipc_msg *m, u32 user, u32 type,
74 u32 hsize, u32 dnode)
Allan Stephens23461e82010-05-11 14:30:18 +000075{
76 memset(m, 0, hsize);
77 msg_set_version(m);
78 msg_set_user(m, user);
79 msg_set_hdr_sz(m, hsize);
80 msg_set_size(m, hsize);
Jon Paul Maloyc5898632015-02-05 08:36:36 -050081 msg_set_prevnode(m, own_node);
Allan Stephens23461e82010-05-11 14:30:18 +000082 msg_set_type(m, type);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040083 if (hsize > SHORT_H_SIZE) {
Jon Paul Maloyc5898632015-02-05 08:36:36 -050084 msg_set_orignode(m, own_node);
85 msg_set_destnode(m, dnode);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040086 }
87}
88
Jon Paul Maloyc5898632015-02-05 08:36:36 -050089struct sk_buff *tipc_msg_create(uint user, uint type,
Ying Xue34747532015-01-09 15:27:10 +080090 uint hdr_sz, uint data_sz, u32 dnode,
91 u32 onode, u32 dport, u32 oport, int errcode)
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040092{
93 struct tipc_msg *msg;
94 struct sk_buff *buf;
95
96 buf = tipc_buf_acquire(hdr_sz + data_sz);
97 if (unlikely(!buf))
98 return NULL;
99
100 msg = buf_msg(buf);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500101 tipc_msg_init(onode, msg, user, type, hdr_sz, dnode);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -0400102 msg_set_size(msg, hdr_sz + data_sz);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -0400103 msg_set_origport(msg, oport);
104 msg_set_destport(msg, dport);
105 msg_set_errcode(msg, errcode);
106 if (hdr_sz > SHORT_H_SIZE) {
107 msg_set_orignode(msg, onode);
108 msg_set_destnode(msg, dnode);
109 }
110 return buf;
Allan Stephens23461e82010-05-11 14:30:18 +0000111}
112
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400113/* tipc_buf_append(): Append a buffer to the fragment list of another buffer
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400114 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call
115 * out: set when successful non-complete reassembly, otherwise NULL
116 * @*buf: in: the buffer to append. Always defined
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700117 * out: head buf after successful complete reassembly, otherwise NULL
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400118 * Returns 1 when reassembly complete, otherwise 0
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400119 */
120int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf)
121{
122 struct sk_buff *head = *headbuf;
123 struct sk_buff *frag = *buf;
124 struct sk_buff *tail;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400125 struct tipc_msg *msg;
126 u32 fragid;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400127 int delta;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400128 bool headstolen;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400129
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400130 if (!frag)
131 goto err;
132
133 msg = buf_msg(frag);
134 fragid = msg_type(msg);
135 frag->next = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400136 skb_pull(frag, msg_hdr_sz(msg));
137
138 if (fragid == FIRST_FRAGMENT) {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400139 if (unlikely(head))
140 goto err;
141 if (unlikely(skb_unclone(frag, GFP_ATOMIC)))
142 goto err;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400143 head = *headbuf = frag;
144 skb_frag_list_init(head);
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400145 TIPC_SKB_CB(head)->tail = NULL;
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400146 *buf = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400147 return 0;
148 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400149
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400150 if (!head)
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400151 goto err;
152
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400153 if (skb_try_coalesce(head, frag, &headstolen, &delta)) {
154 kfree_skb_partial(frag, headstolen);
155 } else {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400156 tail = TIPC_SKB_CB(head)->tail;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400157 if (!skb_has_frag_list(head))
158 skb_shinfo(head)->frag_list = frag;
159 else
160 tail->next = frag;
161 head->truesize += frag->truesize;
162 head->data_len += frag->len;
163 head->len += frag->len;
164 TIPC_SKB_CB(head)->tail = frag;
165 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400166
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400167 if (fragid == LAST_FRAGMENT) {
Jon Paul Maloy11495572015-03-13 16:08:07 -0400168 TIPC_SKB_CB(head)->validated = false;
169 if (unlikely(!tipc_msg_validate(head)))
170 goto err;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400171 *buf = head;
172 TIPC_SKB_CB(head)->tail = NULL;
173 *headbuf = NULL;
174 return 1;
175 }
176 *buf = NULL;
177 return 0;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400178err:
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400179 pr_warn_ratelimited("Unable to build fragment list\n");
180 kfree_skb(*buf);
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400181 kfree_skb(*headbuf);
182 *buf = *headbuf = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400183 return 0;
184}
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500185
Jon Paul Maloycf2157f2015-03-13 16:08:06 -0400186/* tipc_msg_validate - validate basic format of received message
187 *
188 * This routine ensures a TIPC message has an acceptable header, and at least
189 * as much data as the header indicates it should. The routine also ensures
190 * that the entire message header is stored in the main fragment of the message
191 * buffer, to simplify future access to message header fields.
192 *
193 * Note: Having extra info present in the message header or data areas is OK.
194 * TIPC will ignore the excess, under the assumption that it is optional info
195 * introduced by a later release of the protocol.
196 */
197bool tipc_msg_validate(struct sk_buff *skb)
198{
199 struct tipc_msg *msg;
200 int msz, hsz;
201
202 if (unlikely(TIPC_SKB_CB(skb)->validated))
203 return true;
204 if (unlikely(!pskb_may_pull(skb, MIN_H_SIZE)))
205 return false;
206
207 hsz = msg_hdr_sz(buf_msg(skb));
208 if (unlikely(hsz < MIN_H_SIZE) || (hsz > MAX_H_SIZE))
209 return false;
210 if (unlikely(!pskb_may_pull(skb, hsz)))
211 return false;
212
213 msg = buf_msg(skb);
214 if (unlikely(msg_version(msg) != TIPC_VERSION))
215 return false;
216
217 msz = msg_size(msg);
218 if (unlikely(msz < hsz))
219 return false;
220 if (unlikely((msz - hsz) > TIPC_MAX_USER_MSG_SIZE))
221 return false;
222 if (unlikely(skb->len < msz))
223 return false;
224
225 TIPC_SKB_CB(skb)->validated = true;
226 return true;
227}
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500228
229/**
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400230 * tipc_msg_build - create buffer chain containing specified header and data
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500231 * @mhdr: Message header, to be prepended to data
Al Viro45dcc682014-11-15 01:16:27 -0500232 * @m: User message
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500233 * @dsz: Total length of user data
234 * @pktmax: Max packet size that can be used
Ying Xuea6ca1092014-11-26 11:41:55 +0800235 * @list: Buffer or chain of buffers to be returned to caller
236 *
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500237 * Returns message data size or errno: -ENOMEM, -EFAULT
238 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500239int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
Ying Xue34747532015-01-09 15:27:10 +0800240 int offset, int dsz, int pktmax, struct sk_buff_head *list)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500241{
242 int mhsz = msg_hdr_sz(mhdr);
243 int msz = mhsz + dsz;
244 int pktno = 1;
245 int pktsz;
246 int pktrem = pktmax;
247 int drem = dsz;
248 struct tipc_msg pkthdr;
Ying Xuea6ca1092014-11-26 11:41:55 +0800249 struct sk_buff *skb;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500250 char *pktpos;
251 int rc;
Ying Xuea6ca1092014-11-26 11:41:55 +0800252
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500253 msg_set_size(mhdr, msz);
254
255 /* No fragmentation needed? */
256 if (likely(msz <= pktmax)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800257 skb = tipc_buf_acquire(msz);
258 if (unlikely(!skb))
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500259 return -ENOMEM;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800260 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800261 __skb_queue_tail(list, skb);
262 skb_copy_to_linear_data(skb, mhdr, mhsz);
263 pktpos = skb->data + mhsz;
Al Virof25dcc72014-11-28 15:52:29 -0500264 if (copy_from_iter(pktpos, dsz, &m->msg_iter) == dsz)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500265 return dsz;
266 rc = -EFAULT;
267 goto error;
268 }
269
270 /* Prepare reusable fragment header */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500271 tipc_msg_init(msg_prevnode(mhdr), &pkthdr, MSG_FRAGMENTER,
272 FIRST_FRAGMENT, INT_H_SIZE, msg_destnode(mhdr));
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500273 msg_set_size(&pkthdr, pktmax);
274 msg_set_fragm_no(&pkthdr, pktno);
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -0400275 msg_set_importance(&pkthdr, msg_importance(mhdr));
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500276
277 /* Prepare first fragment */
Ying Xuea6ca1092014-11-26 11:41:55 +0800278 skb = tipc_buf_acquire(pktmax);
279 if (!skb)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500280 return -ENOMEM;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800281 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800282 __skb_queue_tail(list, skb);
283 pktpos = skb->data;
284 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500285 pktpos += INT_H_SIZE;
286 pktrem -= INT_H_SIZE;
Ying Xuea6ca1092014-11-26 11:41:55 +0800287 skb_copy_to_linear_data_offset(skb, INT_H_SIZE, mhdr, mhsz);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500288 pktpos += mhsz;
289 pktrem -= mhsz;
290
291 do {
292 if (drem < pktrem)
293 pktrem = drem;
294
Al Virof25dcc72014-11-28 15:52:29 -0500295 if (copy_from_iter(pktpos, pktrem, &m->msg_iter) != pktrem) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500296 rc = -EFAULT;
297 goto error;
298 }
299 drem -= pktrem;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500300
301 if (!drem)
302 break;
303
304 /* Prepare new fragment: */
305 if (drem < (pktmax - INT_H_SIZE))
306 pktsz = drem + INT_H_SIZE;
307 else
308 pktsz = pktmax;
Ying Xuea6ca1092014-11-26 11:41:55 +0800309 skb = tipc_buf_acquire(pktsz);
310 if (!skb) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500311 rc = -ENOMEM;
312 goto error;
313 }
Ying Xuec93d3ba2015-01-09 15:27:04 +0800314 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800315 __skb_queue_tail(list, skb);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500316 msg_set_type(&pkthdr, FRAGMENT);
317 msg_set_size(&pkthdr, pktsz);
318 msg_set_fragm_no(&pkthdr, ++pktno);
Ying Xuea6ca1092014-11-26 11:41:55 +0800319 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
320 pktpos = skb->data + INT_H_SIZE;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500321 pktrem = pktsz - INT_H_SIZE;
322
323 } while (1);
Ying Xuea6ca1092014-11-26 11:41:55 +0800324 msg_set_type(buf_msg(skb), LAST_FRAGMENT);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500325 return dsz;
326error:
Ying Xuea6ca1092014-11-26 11:41:55 +0800327 __skb_queue_purge(list);
328 __skb_queue_head_init(list);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500329 return rc;
330}
331
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500332/**
333 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400334 * @bskb: the buffer to append to ("bundle")
Ying Xue58dc55f2014-11-26 11:41:52 +0800335 * @skb: buffer to be appended
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500336 * @mtu: max allowable size for the bundle buffer
337 * Consumes buffer if successful
338 * Returns true if bundling could be performed, otherwise false
339 */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400340bool tipc_msg_bundle(struct sk_buff *bskb, struct sk_buff *skb, u32 mtu)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500341{
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400342 struct tipc_msg *bmsg;
Ying Xue58dc55f2014-11-26 11:41:52 +0800343 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400344 unsigned int bsz;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500345 unsigned int msz = msg_size(msg);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400346 u32 start, pad;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500347 u32 max = mtu - INT_H_SIZE;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500348
349 if (likely(msg_user(msg) == MSG_FRAGMENTER))
350 return false;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400351 if (!bskb)
352 return false;
353 bmsg = buf_msg(bskb);
354 bsz = msg_size(bmsg);
355 start = align(bsz);
356 pad = start - bsz;
357
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400358 if (unlikely(msg_user(msg) == TUNNEL_PROTOCOL))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500359 return false;
360 if (unlikely(msg_user(msg) == BCAST_PROTOCOL))
361 return false;
362 if (likely(msg_user(bmsg) != MSG_BUNDLER))
363 return false;
Ying Xue58dc55f2014-11-26 11:41:52 +0800364 if (unlikely(skb_tailroom(bskb) < (pad + msz)))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500365 return false;
366 if (unlikely(max < (start + msz)))
367 return false;
368
Ying Xue58dc55f2014-11-26 11:41:52 +0800369 skb_put(bskb, pad + msz);
370 skb_copy_to_linear_data_offset(bskb, start, skb->data, msz);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500371 msg_set_size(bmsg, start + msz);
372 msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1);
Ying Xue58dc55f2014-11-26 11:41:52 +0800373 kfree_skb(skb);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500374 return true;
375}
376
377/**
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500378 * tipc_msg_extract(): extract bundled inner packet from buffer
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400379 * @skb: buffer to be extracted from.
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500380 * @iskb: extracted inner buffer, to be returned
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400381 * @pos: position in outer message of msg to be extracted.
382 * Returns position of next msg
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500383 * Consumes outer buffer when last packet extracted
384 * Returns true when when there is an extracted buffer, otherwise false
385 */
386bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos)
387{
Jon Paul Maloy11495572015-03-13 16:08:07 -0400388 struct tipc_msg *msg;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400389 int imsz, offset;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500390
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400391 *iskb = NULL;
Jon Paul Maloy11495572015-03-13 16:08:07 -0400392 if (unlikely(skb_linearize(skb)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500393 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500394
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400395 msg = buf_msg(skb);
396 offset = msg_hdr_sz(msg) + *pos;
397 if (unlikely(offset > (msg_size(msg) - MIN_H_SIZE)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500398 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400399
400 *iskb = skb_clone(skb, GFP_ATOMIC);
401 if (unlikely(!*iskb))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500402 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400403 skb_pull(*iskb, offset);
404 imsz = msg_size(buf_msg(*iskb));
405 skb_trim(*iskb, imsz);
406 if (unlikely(!tipc_msg_validate(*iskb)))
407 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500408 *pos += align(imsz);
409 return true;
410none:
411 kfree_skb(skb);
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400412 kfree_skb(*iskb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500413 *iskb = NULL;
414 return false;
415}
416
417/**
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500418 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
Ying Xue58dc55f2014-11-26 11:41:52 +0800419 * @list: the buffer chain
420 * @skb: buffer to be appended and replaced
421 * @mtu: max allowable size for the bundle buffer, inclusive header
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500422 * @dnode: destination node for message. (Not always present in header)
423 * Replaces buffer if successful
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700424 * Returns true if success, otherwise false
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500425 */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400426bool tipc_msg_make_bundle(struct sk_buff **skb, u32 mtu, u32 dnode)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500427{
Ying Xue58dc55f2014-11-26 11:41:52 +0800428 struct sk_buff *bskb;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500429 struct tipc_msg *bmsg;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400430 struct tipc_msg *msg = buf_msg(*skb);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500431 u32 msz = msg_size(msg);
432 u32 max = mtu - INT_H_SIZE;
433
434 if (msg_user(msg) == MSG_FRAGMENTER)
435 return false;
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400436 if (msg_user(msg) == TUNNEL_PROTOCOL)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500437 return false;
438 if (msg_user(msg) == BCAST_PROTOCOL)
439 return false;
440 if (msz > (max / 2))
441 return false;
442
Ying Xue58dc55f2014-11-26 11:41:52 +0800443 bskb = tipc_buf_acquire(max);
444 if (!bskb)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500445 return false;
446
Ying Xue58dc55f2014-11-26 11:41:52 +0800447 skb_trim(bskb, INT_H_SIZE);
448 bmsg = buf_msg(bskb);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500449 tipc_msg_init(msg_prevnode(msg), bmsg, MSG_BUNDLER, 0,
450 INT_H_SIZE, dnode);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500451 msg_set_seqno(bmsg, msg_seqno(msg));
452 msg_set_ack(bmsg, msg_ack(msg));
453 msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400454 tipc_msg_bundle(bskb, *skb, mtu);
455 *skb = bskb;
456 return true;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500457}
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500458
459/**
460 * tipc_msg_reverse(): swap source and destination addresses and add error code
461 * @buf: buffer containing message to be reversed
462 * @dnode: return value: node where to send message after reversal
463 * @err: error code to be set in message
464 * Consumes buffer if failure
465 * Returns true if success, otherwise false
466 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500467bool tipc_msg_reverse(u32 own_addr, struct sk_buff *buf, u32 *dnode,
Ying Xue34747532015-01-09 15:27:10 +0800468 int err)
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500469{
470 struct tipc_msg *msg = buf_msg(buf);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500471 struct tipc_msg ohdr;
472 uint rdsz = min_t(uint, msg_data_sz(msg), MAX_FORWARD_SIZE);
473
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500474 if (skb_linearize(buf))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500475 goto exit;
Jon Paul Maloy11495572015-03-13 16:08:07 -0400476 msg = buf_msg(buf);
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500477 if (msg_dest_droppable(msg))
478 goto exit;
479 if (msg_errcode(msg))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500480 goto exit;
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500481 memcpy(&ohdr, msg, msg_hdr_sz(msg));
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500482 msg_set_errcode(msg, err);
483 msg_set_origport(msg, msg_destport(&ohdr));
484 msg_set_destport(msg, msg_origport(&ohdr));
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500485 msg_set_prevnode(msg, own_addr);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500486 if (!msg_short(msg)) {
487 msg_set_orignode(msg, msg_destnode(&ohdr));
488 msg_set_destnode(msg, msg_orignode(&ohdr));
489 }
490 msg_set_size(msg, msg_hdr_sz(msg) + rdsz);
491 skb_trim(buf, msg_size(msg));
492 skb_orphan(buf);
493 *dnode = msg_orignode(&ohdr);
494 return true;
495exit:
496 kfree_skb(buf);
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500497 *dnode = 0;
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500498 return false;
499}
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500500
501/**
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500502 * tipc_msg_lookup_dest(): try to find new destination for named message
503 * @skb: the buffer containing the message.
504 * @dnode: return value: next-hop node, if destination found
505 * @err: return value: error code to use, if message to be rejected
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500506 * Does not consume buffer
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500507 * Returns true if a destination is found, false otherwise
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500508 */
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500509bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb,
510 u32 *dnode, int *err)
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500511{
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500512 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500513 u32 dport;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400514 u32 own_addr = tipc_own_addr(net);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500515
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500516 if (!msg_isdata(msg))
517 return false;
518 if (!msg_named(msg))
519 return false;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400520 if (msg_errcode(msg))
521 return false;
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500522 *err = -TIPC_ERR_NO_NAME;
523 if (skb_linearize(skb))
524 return false;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400525 if (msg_reroute_cnt(msg))
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500526 return false;
Ying Xue34747532015-01-09 15:27:10 +0800527 *dnode = addr_domain(net, msg_lookup_scope(msg));
Ying Xue4ac1c8d2015-01-09 15:27:09 +0800528 dport = tipc_nametbl_translate(net, msg_nametype(msg),
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500529 msg_nameinst(msg), dnode);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500530 if (!dport)
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500531 return false;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500532 msg_incr_reroute_cnt(msg);
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400533 if (*dnode != own_addr)
534 msg_set_prevnode(msg, own_addr);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500535 msg_set_destnode(msg, *dnode);
536 msg_set_destport(msg, dport);
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500537 *err = TIPC_OK;
538 return true;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500539}
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400540
541/* tipc_msg_reassemble() - clone a buffer chain of fragments and
542 * reassemble the clones into one message
543 */
Ying Xuea6ca1092014-11-26 11:41:55 +0800544struct sk_buff *tipc_msg_reassemble(struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400545{
Ying Xuea6ca1092014-11-26 11:41:55 +0800546 struct sk_buff *skb;
547 struct sk_buff *frag = NULL;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400548 struct sk_buff *head = NULL;
549 int hdr_sz;
550
551 /* Copy header if single buffer */
Ying Xuea6ca1092014-11-26 11:41:55 +0800552 if (skb_queue_len(list) == 1) {
553 skb = skb_peek(list);
554 hdr_sz = skb_headroom(skb) + msg_hdr_sz(buf_msg(skb));
555 return __pskb_copy(skb, hdr_sz, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400556 }
557
558 /* Clone all fragments and reassemble */
Ying Xuea6ca1092014-11-26 11:41:55 +0800559 skb_queue_walk(list, skb) {
560 frag = skb_clone(skb, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400561 if (!frag)
562 goto error;
563 frag->next = NULL;
564 if (tipc_buf_append(&head, &frag))
565 break;
566 if (!head)
567 goto error;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400568 }
569 return frag;
570error:
571 pr_warn("Failed do clone local mcast rcv buffer\n");
572 kfree_skb(head);
573 return NULL;
574}