]>
git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - net/tipc/msg.c
2 * net/tipc/msg.c: TIPC message header routines
4 * Copyright (c) 2000-2006, 2014-2015, Ericsson AB
5 * Copyright (c) 2005, 2010-2011, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
41 #include "name_table.h"
43 #define MAX_FORWARD_SIZE 1024
44 #define BUF_HEADROOM (LL_MAX_HEADER + 48)
45 #define BUF_TAILROOM 16
47 static unsigned int align(unsigned int i
)
53 * tipc_buf_acquire - creates a TIPC message buffer
54 * @size: message size (including TIPC header)
56 * Returns a new buffer with data pointers set to the specified size.
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.
61 struct sk_buff
*tipc_buf_acquire(u32 size
, gfp_t gfp
)
64 unsigned int buf_size
= (BUF_HEADROOM
+ size
+ 3) & ~3u;
66 skb
= alloc_skb_fclone(buf_size
, gfp
);
68 skb_reserve(skb
, BUF_HEADROOM
);
75 void tipc_msg_init(u32 own_node
, struct tipc_msg
*m
, u32 user
, u32 type
,
80 msg_set_user(m
, user
);
81 msg_set_hdr_sz(m
, hsize
);
82 msg_set_size(m
, hsize
);
83 msg_set_prevnode(m
, own_node
);
84 msg_set_type(m
, type
);
85 if (hsize
> SHORT_H_SIZE
) {
86 msg_set_orignode(m
, own_node
);
87 msg_set_destnode(m
, dnode
);
91 struct sk_buff
*tipc_msg_create(uint user
, uint type
,
92 uint hdr_sz
, uint data_sz
, u32 dnode
,
93 u32 onode
, u32 dport
, u32 oport
, int errcode
)
98 buf
= tipc_buf_acquire(hdr_sz
+ data_sz
, GFP_ATOMIC
);
103 tipc_msg_init(onode
, msg
, user
, type
, hdr_sz
, dnode
);
104 msg_set_size(msg
, hdr_sz
+ data_sz
);
105 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
);
115 /* tipc_buf_append(): Append a buffer to the fragment list of another buffer
116 * @*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
119 * out: head buf after successful complete reassembly, otherwise NULL
120 * Returns 1 when reassembly complete, otherwise 0
122 int tipc_buf_append(struct sk_buff
**headbuf
, struct sk_buff
**buf
)
124 struct sk_buff
*head
= *headbuf
;
125 struct sk_buff
*frag
= *buf
;
126 struct sk_buff
*tail
= NULL
;
127 struct tipc_msg
*msg
;
136 fragid
= msg_type(msg
);
138 skb_pull(frag
, msg_hdr_sz(msg
));
140 if (fragid
== FIRST_FRAGMENT
) {
143 if (unlikely(skb_unclone(frag
, GFP_ATOMIC
)))
145 head
= *headbuf
= frag
;
147 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
;
153 skb_frag_list_init(head
);
161 if (skb_try_coalesce(head
, frag
, &headstolen
, &delta
)) {
162 kfree_skb_partial(frag
, headstolen
);
164 tail
= TIPC_SKB_CB(head
)->tail
;
165 if (!skb_has_frag_list(head
))
166 skb_shinfo(head
)->frag_list
= frag
;
169 head
->truesize
+= frag
->truesize
;
170 head
->data_len
+= frag
->len
;
171 head
->len
+= frag
->len
;
172 TIPC_SKB_CB(head
)->tail
= frag
;
175 if (fragid
== LAST_FRAGMENT
) {
176 TIPC_SKB_CB(head
)->validated
= false;
177 if (unlikely(!tipc_msg_validate(&head
)))
180 TIPC_SKB_CB(head
)->tail
= NULL
;
189 *buf
= *headbuf
= NULL
;
193 /* tipc_msg_validate - validate basic format of received message
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.
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.
204 bool tipc_msg_validate(struct sk_buff
**_skb
)
206 struct sk_buff
*skb
= *_skb
;
207 struct tipc_msg
*hdr
;
210 /* Ensure that flow control ratio condition is satisfied */
211 if (unlikely(skb
->truesize
/ buf_roundup_len(skb
) >= 4)) {
212 skb
= skb_copy_expand(skb
, BUF_HEADROOM
, 0, GFP_ATOMIC
);
219 if (unlikely(TIPC_SKB_CB(skb
)->validated
))
221 if (unlikely(!pskb_may_pull(skb
, MIN_H_SIZE
)))
224 hsz
= msg_hdr_sz(buf_msg(skb
));
225 if (unlikely(hsz
< MIN_H_SIZE
) || (hsz
> MAX_H_SIZE
))
227 if (unlikely(!pskb_may_pull(skb
, hsz
)))
231 if (unlikely(msg_version(hdr
) != TIPC_VERSION
))
235 if (unlikely(msz
< hsz
))
237 if (unlikely((msz
- hsz
) > TIPC_MAX_USER_MSG_SIZE
))
239 if (unlikely(skb
->len
< msz
))
242 TIPC_SKB_CB(skb
)->validated
= true;
247 * tipc_msg_fragment - build a fragment skb list for TIPC message
249 * @skb: TIPC message skb
250 * @hdr: internal msg header to be put on the top of the fragments
251 * @pktmax: max size of a fragment incl. the header
252 * @frags: returned fragment skb list
254 * Returns 0 if the fragmentation is successful, otherwise: -EINVAL
257 int tipc_msg_fragment(struct sk_buff
*skb
, const struct tipc_msg
*hdr
,
258 int pktmax
, struct sk_buff_head
*frags
)
260 int pktno
, nof_fragms
, dsz
, dmax
, eat
;
261 struct tipc_msg
*_hdr
;
262 struct sk_buff
*_skb
;
265 /* Non-linear buffer? */
266 if (skb_linearize(skb
))
269 data
= (u8
*)skb
->data
;
270 dsz
= msg_size(buf_msg(skb
));
271 dmax
= pktmax
- INT_H_SIZE
;
272 if (dsz
<= dmax
|| !dmax
)
275 nof_fragms
= dsz
/ dmax
+ 1;
276 for (pktno
= 1; pktno
<= nof_fragms
; pktno
++) {
277 if (pktno
< nof_fragms
)
281 /* Allocate a new fragment */
282 _skb
= tipc_buf_acquire(INT_H_SIZE
+ eat
, GFP_ATOMIC
);
286 __skb_queue_tail(frags
, _skb
);
287 /* Copy header & data to the fragment */
288 skb_copy_to_linear_data(_skb
, hdr
, INT_H_SIZE
);
289 skb_copy_to_linear_data_offset(_skb
, INT_H_SIZE
, data
, eat
);
291 /* Update the fragment's header */
292 _hdr
= buf_msg(_skb
);
293 msg_set_fragm_no(_hdr
, pktno
);
294 msg_set_nof_fragms(_hdr
, nof_fragms
);
295 msg_set_size(_hdr
, INT_H_SIZE
+ eat
);
300 __skb_queue_purge(frags
);
301 __skb_queue_head_init(frags
);
306 * tipc_msg_build - create buffer chain containing specified header and data
307 * @mhdr: Message header, to be prepended to data
309 * @dsz: Total length of user data
310 * @pktmax: Max packet size that can be used
311 * @list: Buffer or chain of buffers to be returned to caller
313 * Note that the recursive call we are making here is safe, since it can
314 * logically go only one further level down.
316 * Returns message data size or errno: -ENOMEM, -EFAULT
318 int tipc_msg_build(struct tipc_msg
*mhdr
, struct msghdr
*m
, int offset
,
319 int dsz
, int pktmax
, struct sk_buff_head
*list
)
321 int mhsz
= msg_hdr_sz(mhdr
);
322 struct tipc_msg pkthdr
;
323 int msz
= mhsz
+ dsz
;
332 msg_set_size(mhdr
, msz
);
334 /* No fragmentation needed? */
335 if (likely(msz
<= pktmax
)) {
336 skb
= tipc_buf_acquire(msz
, GFP_KERNEL
);
338 /* Fall back to smaller MTU if node local message */
339 if (unlikely(!skb
)) {
340 if (pktmax
!= MAX_MSG_SIZE
)
342 rc
= tipc_msg_build(mhdr
, m
, offset
, dsz
, FB_MTU
, list
);
345 if (tipc_msg_assemble(list
))
350 __skb_queue_tail(list
, skb
);
351 skb_copy_to_linear_data(skb
, mhdr
, mhsz
);
352 pktpos
= skb
->data
+ mhsz
;
353 if (copy_from_iter_full(pktpos
, dsz
, &m
->msg_iter
))
359 /* Prepare reusable fragment header */
360 tipc_msg_init(msg_prevnode(mhdr
), &pkthdr
, MSG_FRAGMENTER
,
361 FIRST_FRAGMENT
, INT_H_SIZE
, msg_destnode(mhdr
));
362 msg_set_size(&pkthdr
, pktmax
);
363 msg_set_fragm_no(&pkthdr
, pktno
);
364 msg_set_importance(&pkthdr
, msg_importance(mhdr
));
366 /* Prepare first fragment */
367 skb
= tipc_buf_acquire(pktmax
, GFP_KERNEL
);
371 __skb_queue_tail(list
, skb
);
373 skb_copy_to_linear_data(skb
, &pkthdr
, INT_H_SIZE
);
374 pktpos
+= INT_H_SIZE
;
375 pktrem
-= INT_H_SIZE
;
376 skb_copy_to_linear_data_offset(skb
, INT_H_SIZE
, mhdr
, mhsz
);
384 if (!copy_from_iter_full(pktpos
, pktrem
, &m
->msg_iter
)) {
393 /* Prepare new fragment: */
394 if (drem
< (pktmax
- INT_H_SIZE
))
395 pktsz
= drem
+ INT_H_SIZE
;
398 skb
= tipc_buf_acquire(pktsz
, GFP_KERNEL
);
404 __skb_queue_tail(list
, skb
);
405 msg_set_type(&pkthdr
, FRAGMENT
);
406 msg_set_size(&pkthdr
, pktsz
);
407 msg_set_fragm_no(&pkthdr
, ++pktno
);
408 skb_copy_to_linear_data(skb
, &pkthdr
, INT_H_SIZE
);
409 pktpos
= skb
->data
+ INT_H_SIZE
;
410 pktrem
= pktsz
- INT_H_SIZE
;
413 msg_set_type(buf_msg(skb
), LAST_FRAGMENT
);
416 __skb_queue_purge(list
);
417 __skb_queue_head_init(list
);
422 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
423 * @skb: the buffer to append to ("bundle")
424 * @msg: message to be appended
425 * @mtu: max allowable size for the bundle buffer
426 * Consumes buffer if successful
427 * Returns true if bundling could be performed, otherwise false
429 bool tipc_msg_bundle(struct sk_buff
*skb
, struct tipc_msg
*msg
, u32 mtu
)
431 struct tipc_msg
*bmsg
;
433 unsigned int msz
= msg_size(msg
);
435 u32 max
= mtu
- INT_H_SIZE
;
437 if (likely(msg_user(msg
) == MSG_FRAGMENTER
))
442 bsz
= msg_size(bmsg
);
446 if (unlikely(msg_user(msg
) == TUNNEL_PROTOCOL
))
448 if (unlikely(msg_user(msg
) == BCAST_PROTOCOL
))
450 if (unlikely(msg_user(bmsg
) != MSG_BUNDLER
))
452 if (unlikely(skb_tailroom(skb
) < (pad
+ msz
)))
454 if (unlikely(max
< (start
+ msz
)))
456 if ((msg_importance(msg
) < TIPC_SYSTEM_IMPORTANCE
) &&
457 (msg_importance(bmsg
) == TIPC_SYSTEM_IMPORTANCE
))
460 skb_put(skb
, pad
+ msz
);
461 skb_copy_to_linear_data_offset(skb
, start
, msg
, msz
);
462 msg_set_size(bmsg
, start
+ msz
);
463 msg_set_msgcnt(bmsg
, msg_msgcnt(bmsg
) + 1);
468 * tipc_msg_extract(): extract bundled inner packet from buffer
469 * @skb: buffer to be extracted from.
470 * @iskb: extracted inner buffer, to be returned
471 * @pos: position in outer message of msg to be extracted.
472 * Returns position of next msg
473 * Consumes outer buffer when last packet extracted
474 * Returns true when when there is an extracted buffer, otherwise false
476 bool tipc_msg_extract(struct sk_buff
*skb
, struct sk_buff
**iskb
, int *pos
)
478 struct tipc_msg
*hdr
, *ihdr
;
482 if (unlikely(skb_linearize(skb
)))
486 if (unlikely(*pos
> (msg_data_sz(hdr
) - MIN_H_SIZE
)))
489 ihdr
= (struct tipc_msg
*)(msg_data(hdr
) + *pos
);
490 imsz
= msg_size(ihdr
);
492 if ((*pos
+ imsz
) > msg_data_sz(hdr
))
495 *iskb
= tipc_buf_acquire(imsz
, GFP_ATOMIC
);
499 skb_copy_to_linear_data(*iskb
, ihdr
, imsz
);
500 if (unlikely(!tipc_msg_validate(iskb
)))
513 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
514 * @list: the buffer chain, where head is the buffer to replace/append
515 * @skb: buffer to be created, appended to and returned in case of success
516 * @msg: message to be appended
517 * @mtu: max allowable size for the bundle buffer, inclusive header
518 * @dnode: destination node for message. (Not always present in header)
519 * Returns true if success, otherwise false
521 bool tipc_msg_make_bundle(struct sk_buff
**skb
, struct tipc_msg
*msg
,
524 struct sk_buff
*_skb
;
525 struct tipc_msg
*bmsg
;
526 u32 msz
= msg_size(msg
);
527 u32 max
= mtu
- INT_H_SIZE
;
529 if (msg_user(msg
) == MSG_FRAGMENTER
)
531 if (msg_user(msg
) == TUNNEL_PROTOCOL
)
533 if (msg_user(msg
) == BCAST_PROTOCOL
)
538 _skb
= tipc_buf_acquire(max
, GFP_ATOMIC
);
542 skb_trim(_skb
, INT_H_SIZE
);
543 bmsg
= buf_msg(_skb
);
544 tipc_msg_init(msg_prevnode(msg
), bmsg
, MSG_BUNDLER
, 0,
547 msg_set_importance(bmsg
, TIPC_CRITICAL_IMPORTANCE
);
549 msg_set_importance(bmsg
, TIPC_SYSTEM_IMPORTANCE
);
550 msg_set_seqno(bmsg
, msg_seqno(msg
));
551 msg_set_ack(bmsg
, msg_ack(msg
));
552 msg_set_bcast_ack(bmsg
, msg_bcast_ack(msg
));
553 tipc_msg_bundle(_skb
, msg
, mtu
);
559 * tipc_msg_reverse(): swap source and destination addresses and add error code
560 * @own_node: originating node id for reversed message
561 * @skb: buffer containing message to be reversed; will be consumed
562 * @err: error code to be set in message, if any
563 * Replaces consumed buffer with new one when successful
564 * Returns true if success, otherwise false
566 bool tipc_msg_reverse(u32 own_node
, struct sk_buff
**skb
, int err
)
568 struct sk_buff
*_skb
= *skb
;
569 struct tipc_msg
*_hdr
, *hdr
;
572 if (skb_linearize(_skb
))
574 _hdr
= buf_msg(_skb
);
575 dlen
= min_t(uint
, msg_data_sz(_hdr
), MAX_FORWARD_SIZE
);
576 hlen
= msg_hdr_sz(_hdr
);
578 if (msg_dest_droppable(_hdr
))
580 if (msg_errcode(_hdr
))
583 /* Never return SHORT header */
584 if (hlen
== SHORT_H_SIZE
)
587 /* Don't return data along with SYN+, - sender has a clone */
588 if (msg_is_syn(_hdr
) && err
== TIPC_ERR_OVERLOAD
)
591 /* Allocate new buffer to return */
592 *skb
= tipc_buf_acquire(hlen
+ dlen
, GFP_ATOMIC
);
595 memcpy((*skb
)->data
, _skb
->data
, msg_hdr_sz(_hdr
));
596 memcpy((*skb
)->data
+ hlen
, msg_data(_hdr
), dlen
);
598 /* Build reverse header in new buffer */
600 msg_set_hdr_sz(hdr
, hlen
);
601 msg_set_errcode(hdr
, err
);
602 msg_set_non_seq(hdr
, 0);
603 msg_set_origport(hdr
, msg_destport(_hdr
));
604 msg_set_destport(hdr
, msg_origport(_hdr
));
605 msg_set_destnode(hdr
, msg_prevnode(_hdr
));
606 msg_set_prevnode(hdr
, own_node
);
607 msg_set_orignode(hdr
, own_node
);
608 msg_set_size(hdr
, hlen
+ dlen
);
618 bool tipc_msg_skb_clone(struct sk_buff_head
*msg
, struct sk_buff_head
*cpy
)
620 struct sk_buff
*skb
, *_skb
;
622 skb_queue_walk(msg
, skb
) {
623 _skb
= skb_clone(skb
, GFP_ATOMIC
);
625 __skb_queue_purge(cpy
);
626 pr_err_ratelimited("Failed to clone buffer chain\n");
629 __skb_queue_tail(cpy
, _skb
);
635 * tipc_msg_lookup_dest(): try to find new destination for named message
636 * @skb: the buffer containing the message.
637 * @err: error code to be used by caller if lookup fails
638 * Does not consume buffer
639 * Returns true if a destination is found, false otherwise
641 bool tipc_msg_lookup_dest(struct net
*net
, struct sk_buff
*skb
, int *err
)
643 struct tipc_msg
*msg
= buf_msg(skb
);
645 u32 onode
= tipc_own_addr(net
);
647 if (!msg_isdata(msg
))
651 if (msg_errcode(msg
))
653 *err
= TIPC_ERR_NO_NAME
;
654 if (skb_linearize(skb
))
657 if (msg_reroute_cnt(msg
))
659 dnode
= tipc_scope2node(net
, msg_lookup_scope(msg
));
660 dport
= tipc_nametbl_translate(net
, msg_nametype(msg
),
661 msg_nameinst(msg
), &dnode
);
664 msg_incr_reroute_cnt(msg
);
666 msg_set_prevnode(msg
, onode
);
667 msg_set_destnode(msg
, dnode
);
668 msg_set_destport(msg
, dport
);
671 if (!skb_cloned(skb
))
677 /* tipc_msg_assemble() - assemble chain of fragments into one message
679 bool tipc_msg_assemble(struct sk_buff_head
*list
)
681 struct sk_buff
*skb
, *tmp
= NULL
;
683 if (skb_queue_len(list
) == 1)
686 while ((skb
= __skb_dequeue(list
))) {
688 if (tipc_buf_append(&tmp
, &skb
)) {
689 __skb_queue_tail(list
, skb
);
695 __skb_queue_purge(list
);
696 __skb_queue_head_init(list
);
697 pr_warn("Failed do assemble buffer\n");
701 /* tipc_msg_reassemble() - clone a buffer chain of fragments and
702 * reassemble the clones into one message
704 bool tipc_msg_reassemble(struct sk_buff_head
*list
, struct sk_buff_head
*rcvq
)
706 struct sk_buff
*skb
, *_skb
;
707 struct sk_buff
*frag
= NULL
;
708 struct sk_buff
*head
= NULL
;
711 /* Copy header if single buffer */
712 if (skb_queue_len(list
) == 1) {
713 skb
= skb_peek(list
);
714 hdr_len
= skb_headroom(skb
) + msg_hdr_sz(buf_msg(skb
));
715 _skb
= __pskb_copy(skb
, hdr_len
, GFP_ATOMIC
);
718 __skb_queue_tail(rcvq
, _skb
);
722 /* Clone all fragments and reassemble */
723 skb_queue_walk(list
, skb
) {
724 frag
= skb_clone(skb
, GFP_ATOMIC
);
728 if (tipc_buf_append(&head
, &frag
))
733 __skb_queue_tail(rcvq
, frag
);
736 pr_warn("Failed do clone local mcast rcv buffer\n");
741 bool tipc_msg_pskb_copy(u32 dst
, struct sk_buff_head
*msg
,
742 struct sk_buff_head
*cpy
)
744 struct sk_buff
*skb
, *_skb
;
746 skb_queue_walk(msg
, skb
) {
747 _skb
= pskb_copy(skb
, GFP_ATOMIC
);
749 __skb_queue_purge(cpy
);
752 msg_set_destnode(buf_msg(_skb
), dst
);
753 __skb_queue_tail(cpy
, _skb
);
758 /* tipc_skb_queue_sorted(); sort pkt into list according to sequence number
759 * @list: list to be appended to
760 * @seqno: sequence number of buffer to add
761 * @skb: buffer to add
763 void __tipc_skb_queue_sorted(struct sk_buff_head
*list
, u16 seqno
,
766 struct sk_buff
*_skb
, *tmp
;
768 if (skb_queue_empty(list
) || less(seqno
, buf_seqno(skb_peek(list
)))) {
769 __skb_queue_head(list
, skb
);
773 if (more(seqno
, buf_seqno(skb_peek_tail(list
)))) {
774 __skb_queue_tail(list
, skb
);
778 skb_queue_walk_safe(list
, _skb
, tmp
) {
779 if (more(seqno
, buf_seqno(_skb
)))
781 if (seqno
== buf_seqno(_skb
))
783 __skb_queue_before(list
, _skb
, skb
);
789 void tipc_skb_reject(struct net
*net
, int err
, struct sk_buff
*skb
,
790 struct sk_buff_head
*xmitq
)
792 if (tipc_msg_reverse(tipc_own_addr(net
), &skb
, err
))
793 __skb_queue_tail(xmitq
, skb
);