blob: a687b30a699cb651eaf7dd5f1c7d5fa3459bf9b5 [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 Maloy37e22162014-05-14 05:39:12 -04004 * Copyright (c) 2000-2006, 2014, 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
37#include "core.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010038#include "msg.h"
Jon Paul Maloy5a379072014-06-25 20:41:36 -050039#include "addr.h"
40#include "name_table.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010041
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -050042#define MAX_FORWARD_SIZE 1024
43
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050044static unsigned int align(unsigned int i)
Allan Stephens23461e82010-05-11 14:30:18 +000045{
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050046 return (i + 3) & ~3u;
Allan Stephens23461e82010-05-11 14:30:18 +000047}
48
Paul Gortmakerae8509c2013-06-17 10:54:47 -040049void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize,
50 u32 destnode)
Allan Stephens23461e82010-05-11 14:30:18 +000051{
52 memset(m, 0, hsize);
53 msg_set_version(m);
54 msg_set_user(m, user);
55 msg_set_hdr_sz(m, hsize);
56 msg_set_size(m, hsize);
57 msg_set_prevnode(m, tipc_own_addr);
58 msg_set_type(m, type);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040059 if (hsize > SHORT_H_SIZE) {
60 msg_set_orignode(m, tipc_own_addr);
61 msg_set_destnode(m, destnode);
62 }
63}
64
65struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
66 uint data_sz, u32 dnode, u32 onode,
67 u32 dport, u32 oport, int errcode)
68{
69 struct tipc_msg *msg;
70 struct sk_buff *buf;
71
72 buf = tipc_buf_acquire(hdr_sz + data_sz);
73 if (unlikely(!buf))
74 return NULL;
75
76 msg = buf_msg(buf);
77 tipc_msg_init(msg, user, type, hdr_sz, dnode);
78 msg_set_size(msg, hdr_sz + data_sz);
79 msg_set_prevnode(msg, onode);
80 msg_set_origport(msg, oport);
81 msg_set_destport(msg, dport);
82 msg_set_errcode(msg, errcode);
83 if (hdr_sz > SHORT_H_SIZE) {
84 msg_set_orignode(msg, onode);
85 msg_set_destnode(msg, dnode);
86 }
87 return buf;
Allan Stephens23461e82010-05-11 14:30:18 +000088}
89
Jon Paul Maloy37e22162014-05-14 05:39:12 -040090/* tipc_buf_append(): Append a buffer to the fragment list of another buffer
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -040091 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call
92 * out: set when successful non-complete reassembly, otherwise NULL
93 * @*buf: in: the buffer to append. Always defined
stephen hemmingerb2ad5e52014-10-29 22:58:51 -070094 * out: head buf after successful complete reassembly, otherwise NULL
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -040095 * Returns 1 when reassembly complete, otherwise 0
Jon Paul Maloy37e22162014-05-14 05:39:12 -040096 */
97int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf)
98{
99 struct sk_buff *head = *headbuf;
100 struct sk_buff *frag = *buf;
101 struct sk_buff *tail;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400102 struct tipc_msg *msg;
103 u32 fragid;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400104 int delta;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400105 bool headstolen;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400106
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400107 if (!frag)
108 goto err;
109
110 msg = buf_msg(frag);
111 fragid = msg_type(msg);
112 frag->next = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400113 skb_pull(frag, msg_hdr_sz(msg));
114
115 if (fragid == FIRST_FRAGMENT) {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400116 if (unlikely(head))
117 goto err;
118 if (unlikely(skb_unclone(frag, GFP_ATOMIC)))
119 goto err;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400120 head = *headbuf = frag;
121 skb_frag_list_init(head);
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400122 TIPC_SKB_CB(head)->tail = NULL;
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400123 *buf = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400124 return 0;
125 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400126
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400127 if (!head)
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400128 goto err;
129
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400130 if (skb_try_coalesce(head, frag, &headstolen, &delta)) {
131 kfree_skb_partial(frag, headstolen);
132 } else {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400133 tail = TIPC_SKB_CB(head)->tail;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400134 if (!skb_has_frag_list(head))
135 skb_shinfo(head)->frag_list = frag;
136 else
137 tail->next = frag;
138 head->truesize += frag->truesize;
139 head->data_len += frag->len;
140 head->len += frag->len;
141 TIPC_SKB_CB(head)->tail = frag;
142 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400143
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400144 if (fragid == LAST_FRAGMENT) {
145 *buf = head;
146 TIPC_SKB_CB(head)->tail = NULL;
147 *headbuf = NULL;
148 return 1;
149 }
150 *buf = NULL;
151 return 0;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400152
153err:
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400154 pr_warn_ratelimited("Unable to build fragment list\n");
155 kfree_skb(*buf);
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400156 kfree_skb(*headbuf);
157 *buf = *headbuf = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400158 return 0;
159}
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500160
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500161
162/**
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400163 * tipc_msg_build - create buffer chain containing specified header and data
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500164 * @mhdr: Message header, to be prepended to data
Al Viro45dcc682014-11-15 01:16:27 -0500165 * @m: User message
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500166 * @offset: Posision in iov to start copying from
167 * @dsz: Total length of user data
168 * @pktmax: Max packet size that can be used
Ying Xuea6ca1092014-11-26 11:41:55 +0800169 * @list: Buffer or chain of buffers to be returned to caller
170 *
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500171 * Returns message data size or errno: -ENOMEM, -EFAULT
172 */
Ying Xuea6ca1092014-11-26 11:41:55 +0800173int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, int offset,
174 int dsz, int pktmax, struct sk_buff_head *list)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500175{
176 int mhsz = msg_hdr_sz(mhdr);
177 int msz = mhsz + dsz;
178 int pktno = 1;
179 int pktsz;
180 int pktrem = pktmax;
181 int drem = dsz;
182 struct tipc_msg pkthdr;
Ying Xuea6ca1092014-11-26 11:41:55 +0800183 struct sk_buff *skb;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500184 char *pktpos;
185 int rc;
Ying Xuea6ca1092014-11-26 11:41:55 +0800186
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500187 msg_set_size(mhdr, msz);
188
189 /* No fragmentation needed? */
190 if (likely(msz <= pktmax)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800191 skb = tipc_buf_acquire(msz);
192 if (unlikely(!skb))
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500193 return -ENOMEM;
Ying Xuea6ca1092014-11-26 11:41:55 +0800194 __skb_queue_tail(list, skb);
195 skb_copy_to_linear_data(skb, mhdr, mhsz);
196 pktpos = skb->data + mhsz;
Al Viroc0371da2014-11-24 10:42:55 -0500197 if (!dsz || !memcpy_fromiovecend(pktpos, m->msg_iter.iov, offset,
Ying Xuea6ca1092014-11-26 11:41:55 +0800198 dsz))
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500199 return dsz;
200 rc = -EFAULT;
201 goto error;
202 }
203
204 /* Prepare reusable fragment header */
205 tipc_msg_init(&pkthdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
206 INT_H_SIZE, msg_destnode(mhdr));
207 msg_set_size(&pkthdr, pktmax);
208 msg_set_fragm_no(&pkthdr, pktno);
209
210 /* Prepare first fragment */
Ying Xuea6ca1092014-11-26 11:41:55 +0800211 skb = tipc_buf_acquire(pktmax);
212 if (!skb)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500213 return -ENOMEM;
Ying Xuea6ca1092014-11-26 11:41:55 +0800214 __skb_queue_tail(list, skb);
215 pktpos = skb->data;
216 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500217 pktpos += INT_H_SIZE;
218 pktrem -= INT_H_SIZE;
Ying Xuea6ca1092014-11-26 11:41:55 +0800219 skb_copy_to_linear_data_offset(skb, INT_H_SIZE, mhdr, mhsz);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500220 pktpos += mhsz;
221 pktrem -= mhsz;
222
223 do {
224 if (drem < pktrem)
225 pktrem = drem;
226
Al Viroc0371da2014-11-24 10:42:55 -0500227 if (memcpy_fromiovecend(pktpos, m->msg_iter.iov, offset, pktrem)) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500228 rc = -EFAULT;
229 goto error;
230 }
231 drem -= pktrem;
232 offset += pktrem;
233
234 if (!drem)
235 break;
236
237 /* Prepare new fragment: */
238 if (drem < (pktmax - INT_H_SIZE))
239 pktsz = drem + INT_H_SIZE;
240 else
241 pktsz = pktmax;
Ying Xuea6ca1092014-11-26 11:41:55 +0800242 skb = tipc_buf_acquire(pktsz);
243 if (!skb) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500244 rc = -ENOMEM;
245 goto error;
246 }
Ying Xuea6ca1092014-11-26 11:41:55 +0800247 __skb_queue_tail(list, skb);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500248 msg_set_type(&pkthdr, FRAGMENT);
249 msg_set_size(&pkthdr, pktsz);
250 msg_set_fragm_no(&pkthdr, ++pktno);
Ying Xuea6ca1092014-11-26 11:41:55 +0800251 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
252 pktpos = skb->data + INT_H_SIZE;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500253 pktrem = pktsz - INT_H_SIZE;
254
255 } while (1);
Ying Xuea6ca1092014-11-26 11:41:55 +0800256 msg_set_type(buf_msg(skb), LAST_FRAGMENT);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500257 return dsz;
258error:
Ying Xuea6ca1092014-11-26 11:41:55 +0800259 __skb_queue_purge(list);
260 __skb_queue_head_init(list);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500261 return rc;
262}
263
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500264/**
265 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
Ying Xue58dc55f2014-11-26 11:41:52 +0800266 * @list: the buffer chain of the existing buffer ("bundle")
267 * @skb: buffer to be appended
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500268 * @mtu: max allowable size for the bundle buffer
269 * Consumes buffer if successful
270 * Returns true if bundling could be performed, otherwise false
271 */
Ying Xue58dc55f2014-11-26 11:41:52 +0800272bool tipc_msg_bundle(struct sk_buff_head *list, struct sk_buff *skb, u32 mtu)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500273{
Ying Xue58dc55f2014-11-26 11:41:52 +0800274 struct sk_buff *bskb = skb_peek_tail(list);
275 struct tipc_msg *bmsg = buf_msg(bskb);
276 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500277 unsigned int bsz = msg_size(bmsg);
278 unsigned int msz = msg_size(msg);
279 u32 start = align(bsz);
280 u32 max = mtu - INT_H_SIZE;
281 u32 pad = start - bsz;
282
283 if (likely(msg_user(msg) == MSG_FRAGMENTER))
284 return false;
285 if (unlikely(msg_user(msg) == CHANGEOVER_PROTOCOL))
286 return false;
287 if (unlikely(msg_user(msg) == BCAST_PROTOCOL))
288 return false;
289 if (likely(msg_user(bmsg) != MSG_BUNDLER))
290 return false;
Ying Xue58dc55f2014-11-26 11:41:52 +0800291 if (likely(!TIPC_SKB_CB(bskb)->bundling))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500292 return false;
Ying Xue58dc55f2014-11-26 11:41:52 +0800293 if (unlikely(skb_tailroom(bskb) < (pad + msz)))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500294 return false;
295 if (unlikely(max < (start + msz)))
296 return false;
297
Ying Xue58dc55f2014-11-26 11:41:52 +0800298 skb_put(bskb, pad + msz);
299 skb_copy_to_linear_data_offset(bskb, start, skb->data, msz);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500300 msg_set_size(bmsg, start + msz);
301 msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1);
Ying Xue58dc55f2014-11-26 11:41:52 +0800302 kfree_skb(skb);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500303 return true;
304}
305
306/**
307 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
Ying Xue58dc55f2014-11-26 11:41:52 +0800308 * @list: the buffer chain
309 * @skb: buffer to be appended and replaced
310 * @mtu: max allowable size for the bundle buffer, inclusive header
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500311 * @dnode: destination node for message. (Not always present in header)
312 * Replaces buffer if successful
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700313 * Returns true if success, otherwise false
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500314 */
Ying Xue58dc55f2014-11-26 11:41:52 +0800315bool tipc_msg_make_bundle(struct sk_buff_head *list, struct sk_buff *skb,
316 u32 mtu, u32 dnode)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500317{
Ying Xue58dc55f2014-11-26 11:41:52 +0800318 struct sk_buff *bskb;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500319 struct tipc_msg *bmsg;
Ying Xue58dc55f2014-11-26 11:41:52 +0800320 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500321 u32 msz = msg_size(msg);
322 u32 max = mtu - INT_H_SIZE;
323
324 if (msg_user(msg) == MSG_FRAGMENTER)
325 return false;
326 if (msg_user(msg) == CHANGEOVER_PROTOCOL)
327 return false;
328 if (msg_user(msg) == BCAST_PROTOCOL)
329 return false;
330 if (msz > (max / 2))
331 return false;
332
Ying Xue58dc55f2014-11-26 11:41:52 +0800333 bskb = tipc_buf_acquire(max);
334 if (!bskb)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500335 return false;
336
Ying Xue58dc55f2014-11-26 11:41:52 +0800337 skb_trim(bskb, INT_H_SIZE);
338 bmsg = buf_msg(bskb);
Ying Xue58311d12014-11-26 11:41:49 +0800339 tipc_msg_init(bmsg, MSG_BUNDLER, 0, INT_H_SIZE, dnode);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500340 msg_set_seqno(bmsg, msg_seqno(msg));
341 msg_set_ack(bmsg, msg_ack(msg));
342 msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
Ying Xue58dc55f2014-11-26 11:41:52 +0800343 TIPC_SKB_CB(bskb)->bundling = true;
344 __skb_queue_tail(list, bskb);
345 return tipc_msg_bundle(list, skb, mtu);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500346}
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500347
348/**
349 * tipc_msg_reverse(): swap source and destination addresses and add error code
350 * @buf: buffer containing message to be reversed
351 * @dnode: return value: node where to send message after reversal
352 * @err: error code to be set in message
353 * Consumes buffer if failure
354 * Returns true if success, otherwise false
355 */
356bool tipc_msg_reverse(struct sk_buff *buf, u32 *dnode, int err)
357{
358 struct tipc_msg *msg = buf_msg(buf);
359 uint imp = msg_importance(msg);
360 struct tipc_msg ohdr;
361 uint rdsz = min_t(uint, msg_data_sz(msg), MAX_FORWARD_SIZE);
362
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500363 if (skb_linearize(buf))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500364 goto exit;
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500365 if (msg_dest_droppable(msg))
366 goto exit;
367 if (msg_errcode(msg))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500368 goto exit;
369
370 memcpy(&ohdr, msg, msg_hdr_sz(msg));
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500371 imp = min_t(uint, imp + 1, TIPC_CRITICAL_IMPORTANCE);
372 if (msg_isdata(msg))
373 msg_set_importance(msg, imp);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500374 msg_set_errcode(msg, err);
375 msg_set_origport(msg, msg_destport(&ohdr));
376 msg_set_destport(msg, msg_origport(&ohdr));
377 msg_set_prevnode(msg, tipc_own_addr);
378 if (!msg_short(msg)) {
379 msg_set_orignode(msg, msg_destnode(&ohdr));
380 msg_set_destnode(msg, msg_orignode(&ohdr));
381 }
382 msg_set_size(msg, msg_hdr_sz(msg) + rdsz);
383 skb_trim(buf, msg_size(msg));
384 skb_orphan(buf);
385 *dnode = msg_orignode(&ohdr);
386 return true;
387exit:
388 kfree_skb(buf);
389 return false;
390}
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500391
392/**
393 * tipc_msg_eval: determine fate of message that found no destination
394 * @buf: the buffer containing the message.
395 * @dnode: return value: next-hop node, if message to be forwarded
396 * @err: error code to use, if message to be rejected
397 *
398 * Does not consume buffer
399 * Returns 0 (TIPC_OK) if message ok and we can try again, -TIPC error
400 * code if message to be rejected
401 */
402int tipc_msg_eval(struct sk_buff *buf, u32 *dnode)
403{
404 struct tipc_msg *msg = buf_msg(buf);
405 u32 dport;
406
407 if (msg_type(msg) != TIPC_NAMED_MSG)
408 return -TIPC_ERR_NO_PORT;
409 if (skb_linearize(buf))
410 return -TIPC_ERR_NO_NAME;
411 if (msg_data_sz(msg) > MAX_FORWARD_SIZE)
412 return -TIPC_ERR_NO_NAME;
413 if (msg_reroute_cnt(msg) > 0)
414 return -TIPC_ERR_NO_NAME;
415
416 *dnode = addr_domain(msg_lookup_scope(msg));
417 dport = tipc_nametbl_translate(msg_nametype(msg),
418 msg_nameinst(msg),
419 dnode);
420 if (!dport)
421 return -TIPC_ERR_NO_NAME;
422 msg_incr_reroute_cnt(msg);
423 msg_set_destnode(msg, *dnode);
424 msg_set_destport(msg, dport);
425 return TIPC_OK;
426}
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400427
428/* tipc_msg_reassemble() - clone a buffer chain of fragments and
429 * reassemble the clones into one message
430 */
Ying Xuea6ca1092014-11-26 11:41:55 +0800431struct sk_buff *tipc_msg_reassemble(struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400432{
Ying Xuea6ca1092014-11-26 11:41:55 +0800433 struct sk_buff *skb;
434 struct sk_buff *frag = NULL;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400435 struct sk_buff *head = NULL;
436 int hdr_sz;
437
438 /* Copy header if single buffer */
Ying Xuea6ca1092014-11-26 11:41:55 +0800439 if (skb_queue_len(list) == 1) {
440 skb = skb_peek(list);
441 hdr_sz = skb_headroom(skb) + msg_hdr_sz(buf_msg(skb));
442 return __pskb_copy(skb, hdr_sz, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400443 }
444
445 /* Clone all fragments and reassemble */
Ying Xuea6ca1092014-11-26 11:41:55 +0800446 skb_queue_walk(list, skb) {
447 frag = skb_clone(skb, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400448 if (!frag)
449 goto error;
450 frag->next = NULL;
451 if (tipc_buf_append(&head, &frag))
452 break;
453 if (!head)
454 goto error;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400455 }
456 return frag;
457error:
458 pr_warn("Failed do clone local mcast rcv buffer\n");
459 kfree_skb(head);
460 return NULL;
461}