blob: 17201aa8423ddd816a4792621e289dbeee8d4928 [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
Jon Paul Maloy27777da2016-06-20 09:20:46 -040044#define BUF_HEADROOM (LL_MAX_HEADER + 48)
45#define BUF_TAILROOM 16
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -050046
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050047static unsigned int align(unsigned int i)
Allan Stephens23461e82010-05-11 14:30:18 +000048{
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -050049 return (i + 3) & ~3u;
Allan Stephens23461e82010-05-11 14:30:18 +000050}
51
Ying Xue859fc7c2015-01-09 15:27:01 +080052/**
53 * tipc_buf_acquire - creates a TIPC message buffer
54 * @size: message size (including TIPC header)
55 *
56 * Returns a new buffer with data pointers set to the specified size.
57 *
58 * NOTE: Headroom is reserved to allow prepending of a data link header.
59 * There may also be unrequested tailroom present at the buffer's end.
60 */
61struct sk_buff *tipc_buf_acquire(u32 size)
62{
63 struct sk_buff *skb;
64 unsigned int buf_size = (BUF_HEADROOM + size + 3) & ~3u;
65
66 skb = alloc_skb_fclone(buf_size, GFP_ATOMIC);
67 if (skb) {
68 skb_reserve(skb, BUF_HEADROOM);
69 skb_put(skb, size);
70 skb->next = NULL;
71 }
72 return skb;
73}
74
Jon Paul Maloyc5898632015-02-05 08:36:36 -050075void tipc_msg_init(u32 own_node, struct tipc_msg *m, u32 user, u32 type,
76 u32 hsize, u32 dnode)
Allan Stephens23461e82010-05-11 14:30:18 +000077{
78 memset(m, 0, hsize);
79 msg_set_version(m);
80 msg_set_user(m, user);
81 msg_set_hdr_sz(m, hsize);
82 msg_set_size(m, hsize);
Jon Paul Maloyc5898632015-02-05 08:36:36 -050083 msg_set_prevnode(m, own_node);
Allan Stephens23461e82010-05-11 14:30:18 +000084 msg_set_type(m, type);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040085 if (hsize > SHORT_H_SIZE) {
Jon Paul Maloyc5898632015-02-05 08:36:36 -050086 msg_set_orignode(m, own_node);
87 msg_set_destnode(m, dnode);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040088 }
89}
90
Jon Paul Maloyc5898632015-02-05 08:36:36 -050091struct sk_buff *tipc_msg_create(uint user, uint type,
Ying Xue34747532015-01-09 15:27:10 +080092 uint hdr_sz, uint data_sz, u32 dnode,
93 u32 onode, u32 dport, u32 oport, int errcode)
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -040094{
95 struct tipc_msg *msg;
96 struct sk_buff *buf;
97
98 buf = tipc_buf_acquire(hdr_sz + data_sz);
99 if (unlikely(!buf))
100 return NULL;
101
102 msg = buf_msg(buf);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500103 tipc_msg_init(onode, msg, user, type, hdr_sz, dnode);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -0400104 msg_set_size(msg, hdr_sz + data_sz);
Jon Paul Maloy1dd0bd22014-08-22 18:09:06 -0400105 msg_set_origport(msg, oport);
106 msg_set_destport(msg, dport);
107 msg_set_errcode(msg, errcode);
108 if (hdr_sz > SHORT_H_SIZE) {
109 msg_set_orignode(msg, onode);
110 msg_set_destnode(msg, dnode);
111 }
112 return buf;
Allan Stephens23461e82010-05-11 14:30:18 +0000113}
114
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400115/* tipc_buf_append(): Append a buffer to the fragment list of another buffer
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400116 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call
117 * out: set when successful non-complete reassembly, otherwise NULL
118 * @*buf: in: the buffer to append. Always defined
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700119 * out: head buf after successful complete reassembly, otherwise NULL
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400120 * Returns 1 when reassembly complete, otherwise 0
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400121 */
122int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf)
123{
124 struct sk_buff *head = *headbuf;
125 struct sk_buff *frag = *buf;
Jon Paul Maloy45c8b7b2015-10-19 11:33:00 -0400126 struct sk_buff *tail = NULL;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400127 struct tipc_msg *msg;
128 u32 fragid;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400129 int delta;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400130 bool headstolen;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400131
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400132 if (!frag)
133 goto err;
134
135 msg = buf_msg(frag);
136 fragid = msg_type(msg);
137 frag->next = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400138 skb_pull(frag, msg_hdr_sz(msg));
139
140 if (fragid == FIRST_FRAGMENT) {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400141 if (unlikely(head))
142 goto err;
143 if (unlikely(skb_unclone(frag, GFP_ATOMIC)))
144 goto err;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400145 head = *headbuf = frag;
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400146 *buf = NULL;
Jon Paul Maloy45c8b7b2015-10-19 11:33:00 -0400147 TIPC_SKB_CB(head)->tail = NULL;
148 if (skb_is_nonlinear(head)) {
149 skb_walk_frags(head, tail) {
150 TIPC_SKB_CB(head)->tail = tail;
151 }
152 } else {
153 skb_frag_list_init(head);
154 }
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400155 return 0;
156 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400157
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400158 if (!head)
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400159 goto err;
160
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400161 if (skb_try_coalesce(head, frag, &headstolen, &delta)) {
162 kfree_skb_partial(frag, headstolen);
163 } else {
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400164 tail = TIPC_SKB_CB(head)->tail;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400165 if (!skb_has_frag_list(head))
166 skb_shinfo(head)->frag_list = frag;
167 else
168 tail->next = frag;
169 head->truesize += frag->truesize;
170 head->data_len += frag->len;
171 head->len += frag->len;
172 TIPC_SKB_CB(head)->tail = frag;
173 }
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400174
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400175 if (fragid == LAST_FRAGMENT) {
Jon Paul Maloy11495572015-03-13 16:08:07 -0400176 TIPC_SKB_CB(head)->validated = false;
177 if (unlikely(!tipc_msg_validate(head)))
178 goto err;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400179 *buf = head;
180 TIPC_SKB_CB(head)->tail = NULL;
181 *headbuf = NULL;
182 return 1;
183 }
184 *buf = NULL;
185 return 0;
Jon Paul Maloy13e9b992014-07-25 14:48:09 -0400186err:
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400187 kfree_skb(*buf);
Jon Paul Maloy29322d0d2014-07-05 13:44:13 -0400188 kfree_skb(*headbuf);
189 *buf = *headbuf = NULL;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400190 return 0;
191}
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500192
Jon Paul Maloycf2157f2015-03-13 16:08:06 -0400193/* tipc_msg_validate - validate basic format of received message
194 *
195 * This routine ensures a TIPC message has an acceptable header, and at least
196 * as much data as the header indicates it should. The routine also ensures
197 * that the entire message header is stored in the main fragment of the message
198 * buffer, to simplify future access to message header fields.
199 *
200 * Note: Having extra info present in the message header or data areas is OK.
201 * TIPC will ignore the excess, under the assumption that it is optional info
202 * introduced by a later release of the protocol.
203 */
204bool tipc_msg_validate(struct sk_buff *skb)
205{
206 struct tipc_msg *msg;
207 int msz, hsz;
208
209 if (unlikely(TIPC_SKB_CB(skb)->validated))
210 return true;
211 if (unlikely(!pskb_may_pull(skb, MIN_H_SIZE)))
212 return false;
213
214 hsz = msg_hdr_sz(buf_msg(skb));
215 if (unlikely(hsz < MIN_H_SIZE) || (hsz > MAX_H_SIZE))
216 return false;
217 if (unlikely(!pskb_may_pull(skb, hsz)))
218 return false;
219
220 msg = buf_msg(skb);
221 if (unlikely(msg_version(msg) != TIPC_VERSION))
222 return false;
223
224 msz = msg_size(msg);
225 if (unlikely(msz < hsz))
226 return false;
227 if (unlikely((msz - hsz) > TIPC_MAX_USER_MSG_SIZE))
228 return false;
229 if (unlikely(skb->len < msz))
230 return false;
231
232 TIPC_SKB_CB(skb)->validated = true;
233 return true;
234}
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500235
236/**
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400237 * tipc_msg_build - create buffer chain containing specified header and data
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500238 * @mhdr: Message header, to be prepended to data
Al Viro45dcc682014-11-15 01:16:27 -0500239 * @m: User message
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500240 * @dsz: Total length of user data
241 * @pktmax: Max packet size that can be used
Ying Xuea6ca1092014-11-26 11:41:55 +0800242 * @list: Buffer or chain of buffers to be returned to caller
243 *
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500244 * Returns message data size or errno: -ENOMEM, -EFAULT
245 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500246int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
Ying Xue34747532015-01-09 15:27:10 +0800247 int offset, int dsz, int pktmax, struct sk_buff_head *list)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500248{
249 int mhsz = msg_hdr_sz(mhdr);
250 int msz = mhsz + dsz;
251 int pktno = 1;
252 int pktsz;
253 int pktrem = pktmax;
254 int drem = dsz;
255 struct tipc_msg pkthdr;
Ying Xuea6ca1092014-11-26 11:41:55 +0800256 struct sk_buff *skb;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500257 char *pktpos;
258 int rc;
Ying Xuea6ca1092014-11-26 11:41:55 +0800259
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500260 msg_set_size(mhdr, msz);
261
262 /* No fragmentation needed? */
263 if (likely(msz <= pktmax)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800264 skb = tipc_buf_acquire(msz);
265 if (unlikely(!skb))
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500266 return -ENOMEM;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800267 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800268 __skb_queue_tail(list, skb);
269 skb_copy_to_linear_data(skb, mhdr, mhsz);
270 pktpos = skb->data + mhsz;
Al Virof25dcc72014-11-28 15:52:29 -0500271 if (copy_from_iter(pktpos, dsz, &m->msg_iter) == dsz)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500272 return dsz;
273 rc = -EFAULT;
274 goto error;
275 }
276
277 /* Prepare reusable fragment header */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500278 tipc_msg_init(msg_prevnode(mhdr), &pkthdr, MSG_FRAGMENTER,
279 FIRST_FRAGMENT, INT_H_SIZE, msg_destnode(mhdr));
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500280 msg_set_size(&pkthdr, pktmax);
281 msg_set_fragm_no(&pkthdr, pktno);
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -0400282 msg_set_importance(&pkthdr, msg_importance(mhdr));
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500283
284 /* Prepare first fragment */
Ying Xuea6ca1092014-11-26 11:41:55 +0800285 skb = tipc_buf_acquire(pktmax);
286 if (!skb)
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500287 return -ENOMEM;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800288 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800289 __skb_queue_tail(list, skb);
290 pktpos = skb->data;
291 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500292 pktpos += INT_H_SIZE;
293 pktrem -= INT_H_SIZE;
Ying Xuea6ca1092014-11-26 11:41:55 +0800294 skb_copy_to_linear_data_offset(skb, INT_H_SIZE, mhdr, mhsz);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500295 pktpos += mhsz;
296 pktrem -= mhsz;
297
298 do {
299 if (drem < pktrem)
300 pktrem = drem;
301
Al Virof25dcc72014-11-28 15:52:29 -0500302 if (copy_from_iter(pktpos, pktrem, &m->msg_iter) != pktrem) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500303 rc = -EFAULT;
304 goto error;
305 }
306 drem -= pktrem;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500307
308 if (!drem)
309 break;
310
311 /* Prepare new fragment: */
312 if (drem < (pktmax - INT_H_SIZE))
313 pktsz = drem + INT_H_SIZE;
314 else
315 pktsz = pktmax;
Ying Xuea6ca1092014-11-26 11:41:55 +0800316 skb = tipc_buf_acquire(pktsz);
317 if (!skb) {
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500318 rc = -ENOMEM;
319 goto error;
320 }
Ying Xuec93d3ba2015-01-09 15:27:04 +0800321 skb_orphan(skb);
Ying Xuea6ca1092014-11-26 11:41:55 +0800322 __skb_queue_tail(list, skb);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500323 msg_set_type(&pkthdr, FRAGMENT);
324 msg_set_size(&pkthdr, pktsz);
325 msg_set_fragm_no(&pkthdr, ++pktno);
Ying Xuea6ca1092014-11-26 11:41:55 +0800326 skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE);
327 pktpos = skb->data + INT_H_SIZE;
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500328 pktrem = pktsz - INT_H_SIZE;
329
330 } while (1);
Ying Xuea6ca1092014-11-26 11:41:55 +0800331 msg_set_type(buf_msg(skb), LAST_FRAGMENT);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500332 return dsz;
333error:
Ying Xuea6ca1092014-11-26 11:41:55 +0800334 __skb_queue_purge(list);
335 __skb_queue_head_init(list);
Jon Paul Maloy067608e2014-06-25 20:41:34 -0500336 return rc;
337}
338
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500339/**
340 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400341 * @skb: the buffer to append to ("bundle")
342 * @msg: message to be appended
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500343 * @mtu: max allowable size for the bundle buffer
344 * Consumes buffer if successful
345 * Returns true if bundling could be performed, otherwise false
346 */
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400347bool tipc_msg_bundle(struct sk_buff *skb, struct tipc_msg *msg, u32 mtu)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500348{
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400349 struct tipc_msg *bmsg;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400350 unsigned int bsz;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500351 unsigned int msz = msg_size(msg);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400352 u32 start, pad;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500353 u32 max = mtu - INT_H_SIZE;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500354
355 if (likely(msg_user(msg) == MSG_FRAGMENTER))
356 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400357 if (!skb)
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400358 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400359 bmsg = buf_msg(skb);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400360 bsz = msg_size(bmsg);
361 start = align(bsz);
362 pad = start - bsz;
363
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400364 if (unlikely(msg_user(msg) == TUNNEL_PROTOCOL))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500365 return false;
366 if (unlikely(msg_user(msg) == BCAST_PROTOCOL))
367 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400368 if (unlikely(msg_user(bmsg) != MSG_BUNDLER))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500369 return false;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400370 if (unlikely(skb_tailroom(skb) < (pad + msz)))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500371 return false;
372 if (unlikely(max < (start + msz)))
373 return false;
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400374 if ((msg_importance(msg) < TIPC_SYSTEM_IMPORTANCE) &&
375 (msg_importance(bmsg) == TIPC_SYSTEM_IMPORTANCE))
376 return false;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500377
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400378 skb_put(skb, pad + msz);
379 skb_copy_to_linear_data_offset(skb, start, msg, msz);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500380 msg_set_size(bmsg, start + msz);
381 msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500382 return true;
383}
384
385/**
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500386 * tipc_msg_extract(): extract bundled inner packet from buffer
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400387 * @skb: buffer to be extracted from.
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500388 * @iskb: extracted inner buffer, to be returned
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400389 * @pos: position in outer message of msg to be extracted.
390 * Returns position of next msg
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500391 * Consumes outer buffer when last packet extracted
392 * Returns true when when there is an extracted buffer, otherwise false
393 */
394bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos)
395{
Jon Paul Maloy11495572015-03-13 16:08:07 -0400396 struct tipc_msg *msg;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400397 int imsz, offset;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500398
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400399 *iskb = NULL;
Jon Paul Maloy11495572015-03-13 16:08:07 -0400400 if (unlikely(skb_linearize(skb)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500401 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500402
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400403 msg = buf_msg(skb);
404 offset = msg_hdr_sz(msg) + *pos;
405 if (unlikely(offset > (msg_size(msg) - MIN_H_SIZE)))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500406 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400407
408 *iskb = skb_clone(skb, GFP_ATOMIC);
409 if (unlikely(!*iskb))
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500410 goto none;
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400411 skb_pull(*iskb, offset);
412 imsz = msg_size(buf_msg(*iskb));
413 skb_trim(*iskb, imsz);
414 if (unlikely(!tipc_msg_validate(*iskb)))
415 goto none;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500416 *pos += align(imsz);
417 return true;
418none:
419 kfree_skb(skb);
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -0400420 kfree_skb(*iskb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500421 *iskb = NULL;
422 return false;
423}
424
425/**
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500426 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400427 * @list: the buffer chain, where head is the buffer to replace/append
428 * @skb: buffer to be created, appended to and returned in case of success
429 * @msg: message to be appended
Ying Xue58dc55f2014-11-26 11:41:52 +0800430 * @mtu: max allowable size for the bundle buffer, inclusive header
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500431 * @dnode: destination node for message. (Not always present in header)
stephen hemmingerb2ad5e52014-10-29 22:58:51 -0700432 * Returns true if success, otherwise false
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500433 */
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400434bool tipc_msg_make_bundle(struct sk_buff **skb, struct tipc_msg *msg,
435 u32 mtu, u32 dnode)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500436{
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400437 struct sk_buff *_skb;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500438 struct tipc_msg *bmsg;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500439 u32 msz = msg_size(msg);
440 u32 max = mtu - INT_H_SIZE;
441
442 if (msg_user(msg) == MSG_FRAGMENTER)
443 return false;
Jon Paul Maloydff29b12015-04-02 09:33:01 -0400444 if (msg_user(msg) == TUNNEL_PROTOCOL)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500445 return false;
446 if (msg_user(msg) == BCAST_PROTOCOL)
447 return false;
448 if (msz > (max / 2))
449 return false;
450
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400451 _skb = tipc_buf_acquire(max);
452 if (!_skb)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500453 return false;
454
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400455 skb_trim(_skb, INT_H_SIZE);
456 bmsg = buf_msg(_skb);
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500457 tipc_msg_init(msg_prevnode(msg), bmsg, MSG_BUNDLER, 0,
458 INT_H_SIZE, dnode);
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400459 if (msg_isdata(msg))
460 msg_set_importance(bmsg, TIPC_CRITICAL_IMPORTANCE);
461 else
462 msg_set_importance(bmsg, TIPC_SYSTEM_IMPORTANCE);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500463 msg_set_seqno(bmsg, msg_seqno(msg));
464 msg_set_ack(bmsg, msg_ack(msg));
465 msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400466 tipc_msg_bundle(_skb, msg, mtu);
467 *skb = _skb;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400468 return true;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500469}
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500470
471/**
472 * tipc_msg_reverse(): swap source and destination addresses and add error code
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400473 * @own_node: originating node id for reversed message
474 * @skb: buffer containing message to be reversed; may be replaced.
475 * @err: error code to be set in message, if any
476 * Consumes buffer at failure
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500477 * Returns true if success, otherwise false
478 */
Jon Paul Maloybcd3ffd2015-07-22 10:11:19 -0400479bool tipc_msg_reverse(u32 own_node, struct sk_buff **skb, int err)
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500480{
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400481 struct sk_buff *_skb = *skb;
482 struct tipc_msg *hdr = buf_msg(_skb);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500483 struct tipc_msg ohdr;
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400484 int dlen = min_t(uint, msg_data_sz(hdr), MAX_FORWARD_SIZE);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500485
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400486 if (skb_linearize(_skb))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500487 goto exit;
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400488 hdr = buf_msg(_skb);
489 if (msg_dest_droppable(hdr))
Jon Paul Maloyac0074e2014-06-25 20:41:41 -0500490 goto exit;
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400491 if (msg_errcode(hdr))
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500492 goto exit;
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400493
494 /* Take a copy of original header before altering message */
495 memcpy(&ohdr, hdr, msg_hdr_sz(hdr));
496
497 /* Never return SHORT header; expand by replacing buffer if necessary */
498 if (msg_short(hdr)) {
499 *skb = tipc_buf_acquire(BASIC_H_SIZE + dlen);
500 if (!*skb)
501 goto exit;
502 memcpy((*skb)->data + BASIC_H_SIZE, msg_data(hdr), dlen);
503 kfree_skb(_skb);
504 _skb = *skb;
505 hdr = buf_msg(_skb);
506 memcpy(hdr, &ohdr, BASIC_H_SIZE);
507 msg_set_hdr_sz(hdr, BASIC_H_SIZE);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500508 }
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400509
Jon Paul Maloy27777da2016-06-20 09:20:46 -0400510 if (skb_cloned(_skb) &&
511 pskb_expand_head(_skb, BUF_HEADROOM, BUF_TAILROOM, GFP_KERNEL))
512 goto exit;
513
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400514 /* Now reverse the concerned fields */
515 msg_set_errcode(hdr, err);
516 msg_set_origport(hdr, msg_destport(&ohdr));
517 msg_set_destport(hdr, msg_origport(&ohdr));
518 msg_set_destnode(hdr, msg_prevnode(&ohdr));
519 msg_set_prevnode(hdr, own_node);
520 msg_set_orignode(hdr, own_node);
521 msg_set_size(hdr, msg_hdr_sz(hdr) + dlen);
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400522 skb_trim(_skb, msg_size(hdr));
523 skb_orphan(_skb);
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500524 return true;
525exit:
Jon Paul Maloy29042e12015-07-22 10:11:18 -0400526 kfree_skb(_skb);
527 *skb = NULL;
Jon Paul Maloy8db1bae2014-06-25 20:41:35 -0500528 return false;
529}
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500530
531/**
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500532 * tipc_msg_lookup_dest(): try to find new destination for named message
533 * @skb: the buffer containing the message.
Jon Paul Maloycda36962015-07-22 10:11:20 -0400534 * @err: error code to be used by caller if lookup fails
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500535 * Does not consume buffer
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500536 * Returns true if a destination is found, false otherwise
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500537 */
Jon Paul Maloycda36962015-07-22 10:11:20 -0400538bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err)
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500539{
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500540 struct tipc_msg *msg = buf_msg(skb);
Jon Paul Maloycda36962015-07-22 10:11:20 -0400541 u32 dport, dnode;
542 u32 onode = tipc_own_addr(net);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500543
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500544 if (!msg_isdata(msg))
545 return false;
546 if (!msg_named(msg))
547 return false;
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400548 if (msg_errcode(msg))
549 return false;
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500550 *err = -TIPC_ERR_NO_NAME;
551 if (skb_linearize(skb))
552 return false;
Erik Hugne4e3ae002015-09-18 10:46:31 +0200553 msg = buf_msg(skb);
Jon Paul Maloyd4829942015-03-27 10:19:19 -0400554 if (msg_reroute_cnt(msg))
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500555 return false;
Jon Paul Maloycda36962015-07-22 10:11:20 -0400556 dnode = addr_domain(net, msg_lookup_scope(msg));
Ying Xue4ac1c8d2015-01-09 15:27:09 +0800557 dport = tipc_nametbl_translate(net, msg_nametype(msg),
Jon Paul Maloycda36962015-07-22 10:11:20 -0400558 msg_nameinst(msg), &dnode);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500559 if (!dport)
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500560 return false;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500561 msg_incr_reroute_cnt(msg);
Jon Paul Maloycda36962015-07-22 10:11:20 -0400562 if (dnode != onode)
563 msg_set_prevnode(msg, onode);
564 msg_set_destnode(msg, dnode);
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500565 msg_set_destport(msg, dport);
Jon Paul Maloye3a77562015-02-05 08:36:39 -0500566 *err = TIPC_OK;
567 return true;
Jon Paul Maloy5a379072014-06-25 20:41:36 -0500568}
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400569
570/* tipc_msg_reassemble() - clone a buffer chain of fragments and
571 * reassemble the clones into one message
572 */
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400573bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400574{
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400575 struct sk_buff *skb, *_skb;
Ying Xuea6ca1092014-11-26 11:41:55 +0800576 struct sk_buff *frag = NULL;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400577 struct sk_buff *head = NULL;
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400578 int hdr_len;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400579
580 /* Copy header if single buffer */
Ying Xuea6ca1092014-11-26 11:41:55 +0800581 if (skb_queue_len(list) == 1) {
582 skb = skb_peek(list);
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400583 hdr_len = skb_headroom(skb) + msg_hdr_sz(buf_msg(skb));
584 _skb = __pskb_copy(skb, hdr_len, GFP_ATOMIC);
585 if (!_skb)
586 return false;
587 __skb_queue_tail(rcvq, _skb);
588 return true;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400589 }
590
591 /* Clone all fragments and reassemble */
Ying Xuea6ca1092014-11-26 11:41:55 +0800592 skb_queue_walk(list, skb) {
593 frag = skb_clone(skb, GFP_ATOMIC);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400594 if (!frag)
595 goto error;
596 frag->next = NULL;
597 if (tipc_buf_append(&head, &frag))
598 break;
599 if (!head)
600 goto error;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400601 }
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400602 __skb_queue_tail(rcvq, frag);
603 return true;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400604error:
605 pr_warn("Failed do clone local mcast rcv buffer\n");
606 kfree_skb(head);
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400607 return false;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400608}
Jon Paul Maloy8306f992015-10-15 14:52:43 -0400609
610/* tipc_skb_queue_sorted(); sort pkt into list according to sequence number
611 * @list: list to be appended to
612 * @seqno: sequence number of buffer to add
613 * @skb: buffer to add
614 */
615void __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno,
616 struct sk_buff *skb)
617{
618 struct sk_buff *_skb, *tmp;
619
620 if (skb_queue_empty(list) || less(seqno, buf_seqno(skb_peek(list)))) {
621 __skb_queue_head(list, skb);
622 return;
623 }
624
625 if (more(seqno, buf_seqno(skb_peek_tail(list)))) {
626 __skb_queue_tail(list, skb);
627 return;
628 }
629
630 skb_queue_walk_safe(list, _skb, tmp) {
631 if (more(seqno, buf_seqno(_skb)))
632 continue;
633 if (seqno == buf_seqno(_skb))
634 break;
635 __skb_queue_before(list, _skb, skb);
636 return;
637 }
638 kfree_skb(skb);
639}