blob: 08b4cc7d496d94c80fb2fcacc30ade0192fb0dc8 [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 Maloydd3f9e72015-05-14 10:46:18 -0400334 * @skb: the buffer to append to ("bundle")
335 * @msg: message 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 Maloydd3f9e72015-05-14 10:46:18 -0400340bool tipc_msg_bundle(struct sk_buff *skb, struct tipc_msg *msg, u32 mtu)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500341{
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400342 struct tipc_msg *bmsg;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400343 unsigned int bsz;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500344 unsigned int msz = msg_size(msg);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400345 u32 start, pad;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500346 u32 max = mtu - INT_H_SIZE;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500347
348 if (likely(msg_user(msg) == MSG_FRAGMENTER))
349 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400350 if (!skb)
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400351 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400352 bmsg = buf_msg(skb);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400353 bsz = msg_size(bmsg);
354 start = align(bsz);
355 pad = start - bsz;
356
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400357 if (unlikely(msg_user(msg) == TUNNEL_PROTOCOL))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500358 return false;
359 if (unlikely(msg_user(msg) == BCAST_PROTOCOL))
360 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400361 if (unlikely(msg_user(bmsg) != MSG_BUNDLER))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500362 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400363 if (unlikely(skb_tailroom(skb) < (pad + msz)))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500364 return false;
365 if (unlikely(max < (start + msz)))
366 return false;
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400367 if ((msg_importance(msg) < TIPC_SYSTEM_IMPORTANCE) &&
368 (msg_importance(bmsg) == TIPC_SYSTEM_IMPORTANCE))
369 return false;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500370
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400371 skb_put(skb, pad + msz);
372 skb_copy_to_linear_data_offset(skb, start, msg, msz);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500373 msg_set_size(bmsg, start + msz);
374 msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500375 return true;
376}
377
378/**
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500379 * tipc_msg_extract(): extract bundled inner packet from buffer
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400380 * @skb: buffer to be extracted from.
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500381 * @iskb: extracted inner buffer, to be returned
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400382 * @pos: position in outer message of msg to be extracted.
383 * Returns position of next msg
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500384 * Consumes outer buffer when last packet extracted
385 * Returns true when when there is an extracted buffer, otherwise false
386 */
387bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos)
388{
Jon Paul Maloy11495572015-03-13 16:08:07 -0400389 struct tipc_msg *msg;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400390 int imsz, offset;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500391
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400392 *iskb = NULL;
Jon Paul Maloy11495572015-03-13 16:08:07 -0400393 if (unlikely(skb_linearize(skb)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500394 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500395
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400396 msg = buf_msg(skb);
397 offset = msg_hdr_sz(msg) + *pos;
398 if (unlikely(offset > (msg_size(msg) - MIN_H_SIZE)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500399 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400400
401 *iskb = skb_clone(skb, GFP_ATOMIC);
402 if (unlikely(!*iskb))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500403 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400404 skb_pull(*iskb, offset);
405 imsz = msg_size(buf_msg(*iskb));
406 skb_trim(*iskb, imsz);
407 if (unlikely(!tipc_msg_validate(*iskb)))
408 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500409 *pos += align(imsz);
410 return true;
411none:
412 kfree_skb(skb);
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400413 kfree_skb(*iskb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500414 *iskb = NULL;
415 return false;
416}
417
418/**
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500419 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400420 * @list: the buffer chain, where head is the buffer to replace/append
421 * @skb: buffer to be created, appended to and returned in case of success
422 * @msg: message to be appended
Ying Xue58dc55f2014-11-26 11:41:52 +0800423 * @mtu: max allowable size for the bundle buffer, inclusive header
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500424 * @dnode: destination node for message. (Not always present in header)
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700425 * Returns true if success, otherwise false
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500426 */
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400427bool tipc_msg_make_bundle(struct sk_buff **skb, struct tipc_msg *msg,
428 u32 mtu, u32 dnode)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500429{
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400430 struct sk_buff *_skb;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500431 struct tipc_msg *bmsg;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500432 u32 msz = msg_size(msg);
433 u32 max = mtu - INT_H_SIZE;
434
435 if (msg_user(msg) == MSG_FRAGMENTER)
436 return false;
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400437 if (msg_user(msg) == TUNNEL_PROTOCOL)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500438 return false;
439 if (msg_user(msg) == BCAST_PROTOCOL)
440 return false;
441 if (msz > (max / 2))
442 return false;
443
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400444 _skb = tipc_buf_acquire(max);
445 if (!_skb)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500446 return false;
447
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400448 skb_trim(_skb, INT_H_SIZE);
449 bmsg = buf_msg(_skb);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500450 tipc_msg_init(msg_prevnode(msg), bmsg, MSG_BUNDLER, 0,
451 INT_H_SIZE, dnode);
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400452 if (msg_isdata(msg))
453 msg_set_importance(bmsg, TIPC_CRITICAL_IMPORTANCE);
454 else
455 msg_set_importance(bmsg, TIPC_SYSTEM_IMPORTANCE);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500456 msg_set_seqno(bmsg, msg_seqno(msg));
457 msg_set_ack(bmsg, msg_ack(msg));
458 msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400459 tipc_msg_bundle(_skb, msg, mtu);
460 *skb = _skb;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400461 return true;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500462}
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500463
464/**
465 * tipc_msg_reverse(): swap source and destination addresses and add error code
466 * @buf: buffer containing message to be reversed
467 * @dnode: return value: node where to send message after reversal
468 * @err: error code to be set in message
469 * Consumes buffer if failure
470 * Returns true if success, otherwise false
471 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500472bool tipc_msg_reverse(u32 own_addr, struct sk_buff *buf, u32 *dnode,
Ying Xue34747532015-01-09 15:27:10 +0800473 int err)
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500474{
475 struct tipc_msg *msg = buf_msg(buf);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500476 struct tipc_msg ohdr;
477 uint rdsz = min_t(uint, msg_data_sz(msg), MAX_FORWARD_SIZE);
478
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500479 if (skb_linearize(buf))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500480 goto exit;
Jon Paul Maloy11495572015-03-13 16:08:07 -0400481 msg = buf_msg(buf);
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500482 if (msg_dest_droppable(msg))
483 goto exit;
484 if (msg_errcode(msg))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500485 goto exit;
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500486 memcpy(&ohdr, msg, msg_hdr_sz(msg));
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500487 msg_set_errcode(msg, err);
488 msg_set_origport(msg, msg_destport(&ohdr));
489 msg_set_destport(msg, msg_origport(&ohdr));
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500490 msg_set_prevnode(msg, own_addr);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500491 if (!msg_short(msg)) {
492 msg_set_orignode(msg, msg_destnode(&ohdr));
493 msg_set_destnode(msg, msg_orignode(&ohdr));
494 }
495 msg_set_size(msg, msg_hdr_sz(msg) + rdsz);
496 skb_trim(buf, msg_size(msg));
497 skb_orphan(buf);
498 *dnode = msg_orignode(&ohdr);
499 return true;
500exit:
501 kfree_skb(buf);
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500502 *dnode = 0;
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500503 return false;
504}
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500505
506/**
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500507 * tipc_msg_lookup_dest(): try to find new destination for named message
508 * @skb: the buffer containing the message.
509 * @dnode: return value: next-hop node, if destination found
510 * @err: return value: error code to use, if message to be rejected
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500511 * Does not consume buffer
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500512 * Returns true if a destination is found, false otherwise
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500513 */
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500514bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb,
515 u32 *dnode, int *err)
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500516{
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500517 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500518 u32 dport;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400519 u32 own_addr = tipc_own_addr(net);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500520
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500521 if (!msg_isdata(msg))
522 return false;
523 if (!msg_named(msg))
524 return false;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400525 if (msg_errcode(msg))
526 return false;
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500527 *err = -TIPC_ERR_NO_NAME;
528 if (skb_linearize(skb))
529 return false;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400530 if (msg_reroute_cnt(msg))
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500531 return false;
Ying Xue34747532015-01-09 15:27:10 +0800532 *dnode = addr_domain(net, msg_lookup_scope(msg));
Ying Xue4ac1c8d2015-01-09 15:27:09 +0800533 dport = tipc_nametbl_translate(net, msg_nametype(msg),
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500534 msg_nameinst(msg), dnode);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500535 if (!dport)
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500536 return false;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500537 msg_incr_reroute_cnt(msg);
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400538 if (*dnode != own_addr)
539 msg_set_prevnode(msg, own_addr);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500540 msg_set_destnode(msg, *dnode);
541 msg_set_destport(msg, dport);
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500542 *err = TIPC_OK;
543 return true;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500544}
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400545
546/* tipc_msg_reassemble() - clone a buffer chain of fragments and
547 * reassemble the clones into one message
548 */
Ying Xuea6ca1092014-11-26 11:41:55 +0800549struct sk_buff *tipc_msg_reassemble(struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400550{
Ying Xuea6ca1092014-11-26 11:41:55 +0800551 struct sk_buff *skb;
552 struct sk_buff *frag = NULL;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400553 struct sk_buff *head = NULL;
554 int hdr_sz;
555
556 /* Copy header if single buffer */
Ying Xuea6ca1092014-11-26 11:41:55 +0800557 if (skb_queue_len(list) == 1) {
558 skb = skb_peek(list);
559 hdr_sz = skb_headroom(skb) + msg_hdr_sz(buf_msg(skb));
560 return __pskb_copy(skb, hdr_sz, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400561 }
562
563 /* Clone all fragments and reassemble */
Ying Xuea6ca1092014-11-26 11:41:55 +0800564 skb_queue_walk(list, skb) {
565 frag = skb_clone(skb, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400566 if (!frag)
567 goto error;
568 frag->next = NULL;
569 if (tipc_buf_append(&head, &frag))
570 break;
571 if (!head)
572 goto error;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400573 }
574 return frag;
575error:
576 pr_warn("Failed do clone local mcast rcv buffer\n");
577 kfree_skb(head);
578 return NULL;
579}