1 /* 2 * net/tipc/msg.h: Include file for TIPC message header routines 3 * 4 * Copyright (c) 2000-2007, 2014-2017 Ericsson AB 5 * Copyright (c) 2005-2008, 2010-2011, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 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. 19 * 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. 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 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #ifndef _TIPC_MSG_H 38 #define _TIPC_MSG_H 39 40 #include <linux/tipc.h> 41 #include "core.h" 42 43 /* 44 * Constants and routines used to read and write TIPC payload message headers 45 * 46 * Note: Some items are also used with TIPC internal message headers 47 */ 48 #define TIPC_VERSION 2 49 struct plist; 50 51 /* 52 * Payload message users are defined in TIPC's public API: 53 * - TIPC_LOW_IMPORTANCE 54 * - TIPC_MEDIUM_IMPORTANCE 55 * - TIPC_HIGH_IMPORTANCE 56 * - TIPC_CRITICAL_IMPORTANCE 57 */ 58 #define TIPC_SYSTEM_IMPORTANCE 4 59 60 61 /* 62 * Payload message types 63 */ 64 #define TIPC_CONN_MSG 0 65 #define TIPC_MCAST_MSG 1 66 #define TIPC_NAMED_MSG 2 67 #define TIPC_DIRECT_MSG 3 68 #define TIPC_GRP_MEMBER_EVT 4 69 #define TIPC_GRP_BCAST_MSG 5 70 #define TIPC_GRP_MCAST_MSG 6 71 #define TIPC_GRP_UCAST_MSG 7 72 73 /* 74 * Internal message users 75 */ 76 #define BCAST_PROTOCOL 5 77 #define MSG_BUNDLER 6 78 #define LINK_PROTOCOL 7 79 #define CONN_MANAGER 8 80 #define GROUP_PROTOCOL 9 81 #define TUNNEL_PROTOCOL 10 82 #define NAME_DISTRIBUTOR 11 83 #define MSG_FRAGMENTER 12 84 #define LINK_CONFIG 13 85 #define MSG_CRYPTO 14 86 #define SOCK_WAKEUP 14 /* pseudo user */ 87 #define TOP_SRV 15 /* pseudo user */ 88 89 /* 90 * Message header sizes 91 */ 92 #define SHORT_H_SIZE 24 /* In-cluster basic payload message */ 93 #define BASIC_H_SIZE 32 /* Basic payload message */ 94 #define NAMED_H_SIZE 40 /* Named payload message */ 95 #define MCAST_H_SIZE 44 /* Multicast payload message */ 96 #define GROUP_H_SIZE 44 /* Group payload message */ 97 #define INT_H_SIZE 40 /* Internal messages */ 98 #define MIN_H_SIZE 24 /* Smallest legal TIPC header size */ 99 #define MAX_H_SIZE 60 /* Largest possible TIPC header size */ 100 101 #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE) 102 #define FB_MTU 3744 103 #define TIPC_MEDIA_INFO_OFFSET 5 104 105 struct tipc_skb_cb { 106 union { 107 struct { 108 struct sk_buff *tail; 109 unsigned long nxt_retr; 110 unsigned long retr_stamp; 111 u32 bytes_read; 112 u32 orig_member; 113 u16 chain_imp; 114 u16 ackers; 115 u16 retr_cnt; 116 } __packed; 117 #ifdef CONFIG_TIPC_CRYPTO 118 struct { 119 struct tipc_crypto *rx; 120 struct tipc_aead *last; 121 u8 recurs; 122 } tx_clone_ctx __packed; 123 #endif 124 } __packed; 125 union { 126 struct { 127 u8 validated:1; 128 #ifdef CONFIG_TIPC_CRYPTO 129 u8 encrypted:1; 130 u8 decrypted:1; 131 #define SKB_PROBING 1 132 #define SKB_GRACING 2 133 u8 xmit_type:2; 134 u8 tx_clone_deferred:1; 135 #endif 136 }; 137 u8 flags; 138 }; 139 u8 reserved; 140 #ifdef CONFIG_TIPC_CRYPTO 141 void *crypto_ctx; 142 #endif 143 } __packed; 144 145 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0])) 146 147 struct tipc_msg { 148 __be32 hdr[15]; 149 }; 150 151 /* struct tipc_gap_ack - TIPC Gap ACK block 152 * @ack: seqno of the last consecutive packet in link deferdq 153 * @gap: number of gap packets since the last ack 154 * 155 * E.g: 156 * link deferdq: 1 2 3 4 10 11 13 14 15 20 157 * --> Gap ACK blocks: <4, 5>, <11, 1>, <15, 4>, <20, 0> 158 */ 159 struct tipc_gap_ack { 160 __be16 ack; 161 __be16 gap; 162 }; 163 164 /* struct tipc_gap_ack_blks 165 * @len: actual length of the record 166 * @ugack_cnt: number of Gap ACK blocks for unicast (following the broadcast 167 * ones) 168 * @start_index: starting index for "valid" broadcast Gap ACK blocks 169 * @bgack_cnt: number of Gap ACK blocks for broadcast in the record 170 * @gacks: array of Gap ACK blocks 171 * 172 * 31 16 15 0 173 * +-------------+-------------+-------------+-------------+ 174 * | bgack_cnt | ugack_cnt | len | 175 * +-------------+-------------+-------------+-------------+ - 176 * | gap | ack | | 177 * +-------------+-------------+-------------+-------------+ > bc gacks 178 * : : : | 179 * +-------------+-------------+-------------+-------------+ - 180 * | gap | ack | | 181 * +-------------+-------------+-------------+-------------+ > uc gacks 182 * : : : | 183 * +-------------+-------------+-------------+-------------+ - 184 */ 185 struct tipc_gap_ack_blks { 186 __be16 len; 187 union { 188 u8 ugack_cnt; 189 u8 start_index; 190 }; 191 u8 bgack_cnt; 192 struct tipc_gap_ack gacks[]; 193 }; 194 195 #define MAX_GAP_ACK_BLKS 128 196 #define MAX_GAP_ACK_BLKS_SZ (sizeof(struct tipc_gap_ack_blks) + \ 197 sizeof(struct tipc_gap_ack) * MAX_GAP_ACK_BLKS) 198 199 static inline struct tipc_msg *buf_msg(struct sk_buff *skb) 200 { 201 return (struct tipc_msg *)skb->data; 202 } 203 204 static inline u32 msg_word(struct tipc_msg *m, u32 pos) 205 { 206 return ntohl(m->hdr[pos]); 207 } 208 209 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val) 210 { 211 m->hdr[w] = htonl(val); 212 } 213 214 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask) 215 { 216 return (msg_word(m, w) >> pos) & mask; 217 } 218 219 static inline void msg_set_bits(struct tipc_msg *m, u32 w, 220 u32 pos, u32 mask, u32 val) 221 { 222 val = (val & mask) << pos; 223 mask = mask << pos; 224 m->hdr[w] &= ~htonl(mask); 225 m->hdr[w] |= htonl(val); 226 } 227 228 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b) 229 { 230 u32 temp = msg->hdr[a]; 231 232 msg->hdr[a] = msg->hdr[b]; 233 msg->hdr[b] = temp; 234 } 235 236 /* 237 * Word 0 238 */ 239 static inline u32 msg_version(struct tipc_msg *m) 240 { 241 return msg_bits(m, 0, 29, 7); 242 } 243 244 static inline void msg_set_version(struct tipc_msg *m) 245 { 246 msg_set_bits(m, 0, 29, 7, TIPC_VERSION); 247 } 248 249 static inline u32 msg_user(struct tipc_msg *m) 250 { 251 return msg_bits(m, 0, 25, 0xf); 252 } 253 254 static inline u32 msg_isdata(struct tipc_msg *m) 255 { 256 return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE; 257 } 258 259 static inline void msg_set_user(struct tipc_msg *m, u32 n) 260 { 261 msg_set_bits(m, 0, 25, 0xf, n); 262 } 263 264 static inline u32 msg_hdr_sz(struct tipc_msg *m) 265 { 266 return msg_bits(m, 0, 21, 0xf) << 2; 267 } 268 269 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n) 270 { 271 msg_set_bits(m, 0, 21, 0xf, n>>2); 272 } 273 274 static inline u32 msg_size(struct tipc_msg *m) 275 { 276 return msg_bits(m, 0, 0, 0x1ffff); 277 } 278 279 static inline u32 msg_blocks(struct tipc_msg *m) 280 { 281 return (msg_size(m) / 1024) + 1; 282 } 283 284 static inline u32 msg_data_sz(struct tipc_msg *m) 285 { 286 return msg_size(m) - msg_hdr_sz(m); 287 } 288 289 static inline int msg_non_seq(struct tipc_msg *m) 290 { 291 return msg_bits(m, 0, 20, 1); 292 } 293 294 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n) 295 { 296 msg_set_bits(m, 0, 20, 1, n); 297 } 298 299 static inline int msg_is_syn(struct tipc_msg *m) 300 { 301 return msg_bits(m, 0, 17, 1); 302 } 303 304 static inline void msg_set_syn(struct tipc_msg *m, u32 d) 305 { 306 msg_set_bits(m, 0, 17, 1, d); 307 } 308 309 static inline int msg_dest_droppable(struct tipc_msg *m) 310 { 311 return msg_bits(m, 0, 19, 1); 312 } 313 314 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d) 315 { 316 msg_set_bits(m, 0, 19, 1, d); 317 } 318 319 static inline int msg_is_keepalive(struct tipc_msg *m) 320 { 321 return msg_bits(m, 0, 19, 1); 322 } 323 324 static inline void msg_set_is_keepalive(struct tipc_msg *m, u32 d) 325 { 326 msg_set_bits(m, 0, 19, 1, d); 327 } 328 329 static inline int msg_src_droppable(struct tipc_msg *m) 330 { 331 return msg_bits(m, 0, 18, 1); 332 } 333 334 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d) 335 { 336 msg_set_bits(m, 0, 18, 1, d); 337 } 338 339 static inline int msg_ack_required(struct tipc_msg *m) 340 { 341 return msg_bits(m, 0, 18, 1); 342 } 343 344 static inline void msg_set_ack_required(struct tipc_msg *m) 345 { 346 msg_set_bits(m, 0, 18, 1, 1); 347 } 348 349 static inline int msg_nagle_ack(struct tipc_msg *m) 350 { 351 return msg_bits(m, 0, 18, 1); 352 } 353 354 static inline void msg_set_nagle_ack(struct tipc_msg *m) 355 { 356 msg_set_bits(m, 0, 18, 1, 1); 357 } 358 359 static inline bool msg_is_rcast(struct tipc_msg *m) 360 { 361 return msg_bits(m, 0, 18, 0x1); 362 } 363 364 static inline void msg_set_is_rcast(struct tipc_msg *m, bool d) 365 { 366 msg_set_bits(m, 0, 18, 0x1, d); 367 } 368 369 static inline void msg_set_size(struct tipc_msg *m, u32 sz) 370 { 371 m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz); 372 } 373 374 static inline unchar *msg_data(struct tipc_msg *m) 375 { 376 return ((unchar *)m) + msg_hdr_sz(m); 377 } 378 379 static inline struct tipc_msg *msg_inner_hdr(struct tipc_msg *m) 380 { 381 return (struct tipc_msg *)msg_data(m); 382 } 383 384 /* 385 * Word 1 386 */ 387 static inline u32 msg_type(struct tipc_msg *m) 388 { 389 return msg_bits(m, 1, 29, 0x7); 390 } 391 392 static inline void msg_set_type(struct tipc_msg *m, u32 n) 393 { 394 msg_set_bits(m, 1, 29, 0x7, n); 395 } 396 397 static inline int msg_in_group(struct tipc_msg *m) 398 { 399 int mtyp = msg_type(m); 400 401 return mtyp >= TIPC_GRP_MEMBER_EVT && mtyp <= TIPC_GRP_UCAST_MSG; 402 } 403 404 static inline bool msg_is_grp_evt(struct tipc_msg *m) 405 { 406 return msg_type(m) == TIPC_GRP_MEMBER_EVT; 407 } 408 409 static inline u32 msg_named(struct tipc_msg *m) 410 { 411 return msg_type(m) == TIPC_NAMED_MSG; 412 } 413 414 static inline u32 msg_mcast(struct tipc_msg *m) 415 { 416 int mtyp = msg_type(m); 417 418 return ((mtyp == TIPC_MCAST_MSG) || (mtyp == TIPC_GRP_BCAST_MSG) || 419 (mtyp == TIPC_GRP_MCAST_MSG)); 420 } 421 422 static inline u32 msg_connected(struct tipc_msg *m) 423 { 424 return msg_type(m) == TIPC_CONN_MSG; 425 } 426 427 static inline u32 msg_direct(struct tipc_msg *m) 428 { 429 return msg_type(m) == TIPC_DIRECT_MSG; 430 } 431 432 static inline u32 msg_errcode(struct tipc_msg *m) 433 { 434 return msg_bits(m, 1, 25, 0xf); 435 } 436 437 static inline void msg_set_errcode(struct tipc_msg *m, u32 err) 438 { 439 msg_set_bits(m, 1, 25, 0xf, err); 440 } 441 442 static inline void msg_set_bulk(struct tipc_msg *m) 443 { 444 msg_set_bits(m, 1, 28, 0x1, 1); 445 } 446 447 static inline u32 msg_is_bulk(struct tipc_msg *m) 448 { 449 return msg_bits(m, 1, 28, 0x1); 450 } 451 452 static inline void msg_set_last_bulk(struct tipc_msg *m) 453 { 454 msg_set_bits(m, 1, 27, 0x1, 1); 455 } 456 457 static inline u32 msg_is_last_bulk(struct tipc_msg *m) 458 { 459 return msg_bits(m, 1, 27, 0x1); 460 } 461 462 static inline void msg_set_non_legacy(struct tipc_msg *m) 463 { 464 msg_set_bits(m, 1, 26, 0x1, 1); 465 } 466 467 static inline u32 msg_is_legacy(struct tipc_msg *m) 468 { 469 return !msg_bits(m, 1, 26, 0x1); 470 } 471 472 static inline u32 msg_reroute_cnt(struct tipc_msg *m) 473 { 474 return msg_bits(m, 1, 21, 0xf); 475 } 476 477 static inline void msg_incr_reroute_cnt(struct tipc_msg *m) 478 { 479 msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1); 480 } 481 482 static inline void msg_reset_reroute_cnt(struct tipc_msg *m) 483 { 484 msg_set_bits(m, 1, 21, 0xf, 0); 485 } 486 487 static inline u32 msg_lookup_scope(struct tipc_msg *m) 488 { 489 return msg_bits(m, 1, 19, 0x3); 490 } 491 492 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n) 493 { 494 msg_set_bits(m, 1, 19, 0x3, n); 495 } 496 497 static inline u16 msg_bcast_ack(struct tipc_msg *m) 498 { 499 return msg_bits(m, 1, 0, 0xffff); 500 } 501 502 static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n) 503 { 504 msg_set_bits(m, 1, 0, 0xffff, n); 505 } 506 507 /* Note: reusing bits in word 1 for ACTIVATE_MSG only, to re-synch 508 * link peer session number 509 */ 510 static inline bool msg_dest_session_valid(struct tipc_msg *m) 511 { 512 return msg_bits(m, 1, 16, 0x1); 513 } 514 515 static inline void msg_set_dest_session_valid(struct tipc_msg *m, bool valid) 516 { 517 msg_set_bits(m, 1, 16, 0x1, valid); 518 } 519 520 static inline u16 msg_dest_session(struct tipc_msg *m) 521 { 522 return msg_bits(m, 1, 0, 0xffff); 523 } 524 525 static inline void msg_set_dest_session(struct tipc_msg *m, u16 n) 526 { 527 msg_set_bits(m, 1, 0, 0xffff, n); 528 } 529 530 /* 531 * Word 2 532 */ 533 static inline u16 msg_ack(struct tipc_msg *m) 534 { 535 return msg_bits(m, 2, 16, 0xffff); 536 } 537 538 static inline void msg_set_ack(struct tipc_msg *m, u16 n) 539 { 540 msg_set_bits(m, 2, 16, 0xffff, n); 541 } 542 543 static inline u16 msg_seqno(struct tipc_msg *m) 544 { 545 return msg_bits(m, 2, 0, 0xffff); 546 } 547 548 static inline void msg_set_seqno(struct tipc_msg *m, u16 n) 549 { 550 msg_set_bits(m, 2, 0, 0xffff, n); 551 } 552 553 /* 554 * Words 3-10 555 */ 556 static inline u32 msg_importance(struct tipc_msg *m) 557 { 558 int usr = msg_user(m); 559 560 if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m))) 561 return usr; 562 if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)) 563 return msg_bits(m, 9, 0, 0x7); 564 return TIPC_SYSTEM_IMPORTANCE; 565 } 566 567 static inline void msg_set_importance(struct tipc_msg *m, u32 i) 568 { 569 int usr = msg_user(m); 570 571 if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))) 572 msg_set_bits(m, 9, 0, 0x7, i); 573 else if (i < TIPC_SYSTEM_IMPORTANCE) 574 msg_set_user(m, i); 575 else 576 pr_warn("Trying to set illegal importance in message\n"); 577 } 578 579 static inline u32 msg_prevnode(struct tipc_msg *m) 580 { 581 return msg_word(m, 3); 582 } 583 584 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a) 585 { 586 msg_set_word(m, 3, a); 587 } 588 589 static inline u32 msg_origport(struct tipc_msg *m) 590 { 591 if (msg_user(m) == MSG_FRAGMENTER) 592 m = msg_inner_hdr(m); 593 return msg_word(m, 4); 594 } 595 596 static inline void msg_set_origport(struct tipc_msg *m, u32 p) 597 { 598 msg_set_word(m, 4, p); 599 } 600 601 static inline u16 msg_named_seqno(struct tipc_msg *m) 602 { 603 return msg_bits(m, 4, 0, 0xffff); 604 } 605 606 static inline void msg_set_named_seqno(struct tipc_msg *m, u16 n) 607 { 608 msg_set_bits(m, 4, 0, 0xffff, n); 609 } 610 611 static inline u32 msg_destport(struct tipc_msg *m) 612 { 613 return msg_word(m, 5); 614 } 615 616 static inline void msg_set_destport(struct tipc_msg *m, u32 p) 617 { 618 msg_set_word(m, 5, p); 619 } 620 621 static inline u32 msg_mc_netid(struct tipc_msg *m) 622 { 623 return msg_word(m, 5); 624 } 625 626 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p) 627 { 628 msg_set_word(m, 5, p); 629 } 630 631 static inline int msg_short(struct tipc_msg *m) 632 { 633 return msg_hdr_sz(m) == SHORT_H_SIZE; 634 } 635 636 static inline u32 msg_orignode(struct tipc_msg *m) 637 { 638 if (likely(msg_short(m))) 639 return msg_prevnode(m); 640 return msg_word(m, 6); 641 } 642 643 static inline void msg_set_orignode(struct tipc_msg *m, u32 a) 644 { 645 msg_set_word(m, 6, a); 646 } 647 648 static inline u32 msg_destnode(struct tipc_msg *m) 649 { 650 return msg_word(m, 7); 651 } 652 653 static inline void msg_set_destnode(struct tipc_msg *m, u32 a) 654 { 655 msg_set_word(m, 7, a); 656 } 657 658 static inline u32 msg_nametype(struct tipc_msg *m) 659 { 660 return msg_word(m, 8); 661 } 662 663 static inline void msg_set_nametype(struct tipc_msg *m, u32 n) 664 { 665 msg_set_word(m, 8, n); 666 } 667 668 static inline u32 msg_nameinst(struct tipc_msg *m) 669 { 670 return msg_word(m, 9); 671 } 672 673 static inline u32 msg_namelower(struct tipc_msg *m) 674 { 675 return msg_nameinst(m); 676 } 677 678 static inline void msg_set_namelower(struct tipc_msg *m, u32 n) 679 { 680 msg_set_word(m, 9, n); 681 } 682 683 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n) 684 { 685 msg_set_namelower(m, n); 686 } 687 688 static inline u32 msg_nameupper(struct tipc_msg *m) 689 { 690 return msg_word(m, 10); 691 } 692 693 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n) 694 { 695 msg_set_word(m, 10, n); 696 } 697 698 /* 699 * Constants and routines used to read and write TIPC internal message headers 700 */ 701 702 /* 703 * Connection management protocol message types 704 */ 705 #define CONN_PROBE 0 706 #define CONN_PROBE_REPLY 1 707 #define CONN_ACK 2 708 709 /* 710 * Name distributor message types 711 */ 712 #define PUBLICATION 0 713 #define WITHDRAWAL 1 714 715 /* 716 * Segmentation message types 717 */ 718 #define FIRST_FRAGMENT 0 719 #define FRAGMENT 1 720 #define LAST_FRAGMENT 2 721 722 /* 723 * Link management protocol message types 724 */ 725 #define STATE_MSG 0 726 #define RESET_MSG 1 727 #define ACTIVATE_MSG 2 728 729 /* 730 * Changeover tunnel message types 731 */ 732 #define SYNCH_MSG 0 733 #define FAILOVER_MSG 1 734 735 /* 736 * Config protocol message types 737 */ 738 #define DSC_REQ_MSG 0 739 #define DSC_RESP_MSG 1 740 #define DSC_TRIAL_MSG 2 741 #define DSC_TRIAL_FAIL_MSG 3 742 743 /* 744 * Group protocol message types 745 */ 746 #define GRP_JOIN_MSG 0 747 #define GRP_LEAVE_MSG 1 748 #define GRP_ADV_MSG 2 749 #define GRP_ACK_MSG 3 750 #define GRP_RECLAIM_MSG 4 751 #define GRP_REMIT_MSG 5 752 753 /* Crypto message types */ 754 #define KEY_DISTR_MSG 0 755 756 /* 757 * Word 1 758 */ 759 static inline u32 msg_seq_gap(struct tipc_msg *m) 760 { 761 return msg_bits(m, 1, 16, 0x1fff); 762 } 763 764 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n) 765 { 766 msg_set_bits(m, 1, 16, 0x1fff, n); 767 } 768 769 static inline u32 msg_node_sig(struct tipc_msg *m) 770 { 771 return msg_bits(m, 1, 0, 0xffff); 772 } 773 774 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n) 775 { 776 msg_set_bits(m, 1, 0, 0xffff, n); 777 } 778 779 static inline u32 msg_node_capabilities(struct tipc_msg *m) 780 { 781 return msg_bits(m, 1, 15, 0x1fff); 782 } 783 784 static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n) 785 { 786 msg_set_bits(m, 1, 15, 0x1fff, n); 787 } 788 789 /* 790 * Word 2 791 */ 792 static inline u32 msg_dest_domain(struct tipc_msg *m) 793 { 794 return msg_word(m, 2); 795 } 796 797 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n) 798 { 799 msg_set_word(m, 2, n); 800 } 801 802 static inline u32 msg_bcgap_after(struct tipc_msg *m) 803 { 804 return msg_bits(m, 2, 16, 0xffff); 805 } 806 807 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n) 808 { 809 msg_set_bits(m, 2, 16, 0xffff, n); 810 } 811 812 static inline u32 msg_bcgap_to(struct tipc_msg *m) 813 { 814 return msg_bits(m, 2, 0, 0xffff); 815 } 816 817 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n) 818 { 819 msg_set_bits(m, 2, 0, 0xffff, n); 820 } 821 822 /* 823 * Word 4 824 */ 825 static inline u32 msg_last_bcast(struct tipc_msg *m) 826 { 827 return msg_bits(m, 4, 16, 0xffff); 828 } 829 830 static inline u32 msg_bc_snd_nxt(struct tipc_msg *m) 831 { 832 return msg_last_bcast(m) + 1; 833 } 834 835 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n) 836 { 837 msg_set_bits(m, 4, 16, 0xffff, n); 838 } 839 840 static inline u32 msg_nof_fragms(struct tipc_msg *m) 841 { 842 return msg_bits(m, 4, 0, 0xffff); 843 } 844 845 static inline void msg_set_nof_fragms(struct tipc_msg *m, u32 n) 846 { 847 msg_set_bits(m, 4, 0, 0xffff, n); 848 } 849 850 static inline u32 msg_fragm_no(struct tipc_msg *m) 851 { 852 return msg_bits(m, 4, 16, 0xffff); 853 } 854 855 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n) 856 { 857 msg_set_bits(m, 4, 16, 0xffff, n); 858 } 859 860 static inline u16 msg_next_sent(struct tipc_msg *m) 861 { 862 return msg_bits(m, 4, 0, 0xffff); 863 } 864 865 static inline void msg_set_next_sent(struct tipc_msg *m, u16 n) 866 { 867 msg_set_bits(m, 4, 0, 0xffff, n); 868 } 869 870 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n) 871 { 872 msg_set_bits(m, 4, 0, 0xffff, n); 873 } 874 875 static inline u32 msg_bc_netid(struct tipc_msg *m) 876 { 877 return msg_word(m, 4); 878 } 879 880 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id) 881 { 882 msg_set_word(m, 4, id); 883 } 884 885 static inline u32 msg_link_selector(struct tipc_msg *m) 886 { 887 if (msg_user(m) == MSG_FRAGMENTER) 888 m = (void *)msg_data(m); 889 return msg_bits(m, 4, 0, 1); 890 } 891 892 /* 893 * Word 5 894 */ 895 static inline u16 msg_session(struct tipc_msg *m) 896 { 897 return msg_bits(m, 5, 16, 0xffff); 898 } 899 900 static inline void msg_set_session(struct tipc_msg *m, u16 n) 901 { 902 msg_set_bits(m, 5, 16, 0xffff, n); 903 } 904 905 static inline u32 msg_probe(struct tipc_msg *m) 906 { 907 return msg_bits(m, 5, 0, 1); 908 } 909 910 static inline void msg_set_probe(struct tipc_msg *m, u32 val) 911 { 912 msg_set_bits(m, 5, 0, 1, val); 913 } 914 915 static inline char msg_net_plane(struct tipc_msg *m) 916 { 917 return msg_bits(m, 5, 1, 7) + 'A'; 918 } 919 920 static inline void msg_set_net_plane(struct tipc_msg *m, char n) 921 { 922 msg_set_bits(m, 5, 1, 7, (n - 'A')); 923 } 924 925 static inline u32 msg_linkprio(struct tipc_msg *m) 926 { 927 return msg_bits(m, 5, 4, 0x1f); 928 } 929 930 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n) 931 { 932 msg_set_bits(m, 5, 4, 0x1f, n); 933 } 934 935 static inline u32 msg_bearer_id(struct tipc_msg *m) 936 { 937 return msg_bits(m, 5, 9, 0x7); 938 } 939 940 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n) 941 { 942 msg_set_bits(m, 5, 9, 0x7, n); 943 } 944 945 static inline u32 msg_redundant_link(struct tipc_msg *m) 946 { 947 return msg_bits(m, 5, 12, 0x1); 948 } 949 950 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r) 951 { 952 msg_set_bits(m, 5, 12, 0x1, r); 953 } 954 955 static inline u32 msg_peer_stopping(struct tipc_msg *m) 956 { 957 return msg_bits(m, 5, 13, 0x1); 958 } 959 960 static inline void msg_set_peer_stopping(struct tipc_msg *m, u32 s) 961 { 962 msg_set_bits(m, 5, 13, 0x1, s); 963 } 964 965 static inline bool msg_bc_ack_invalid(struct tipc_msg *m) 966 { 967 switch (msg_user(m)) { 968 case BCAST_PROTOCOL: 969 case NAME_DISTRIBUTOR: 970 case LINK_PROTOCOL: 971 return msg_bits(m, 5, 14, 0x1); 972 default: 973 return false; 974 } 975 } 976 977 static inline void msg_set_bc_ack_invalid(struct tipc_msg *m, bool invalid) 978 { 979 msg_set_bits(m, 5, 14, 0x1, invalid); 980 } 981 982 static inline char *msg_media_addr(struct tipc_msg *m) 983 { 984 return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET]; 985 } 986 987 static inline u32 msg_bc_gap(struct tipc_msg *m) 988 { 989 return msg_bits(m, 8, 0, 0x3ff); 990 } 991 992 static inline void msg_set_bc_gap(struct tipc_msg *m, u32 n) 993 { 994 msg_set_bits(m, 8, 0, 0x3ff, n); 995 } 996 997 /* 998 * Word 9 999 */ 1000 static inline u16 msg_msgcnt(struct tipc_msg *m) 1001 { 1002 return msg_bits(m, 9, 16, 0xffff); 1003 } 1004 1005 static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n) 1006 { 1007 msg_set_bits(m, 9, 16, 0xffff, n); 1008 } 1009 1010 static inline u16 msg_syncpt(struct tipc_msg *m) 1011 { 1012 return msg_bits(m, 9, 16, 0xffff); 1013 } 1014 1015 static inline void msg_set_syncpt(struct tipc_msg *m, u16 n) 1016 { 1017 msg_set_bits(m, 9, 16, 0xffff, n); 1018 } 1019 1020 static inline u32 msg_conn_ack(struct tipc_msg *m) 1021 { 1022 return msg_bits(m, 9, 16, 0xffff); 1023 } 1024 1025 static inline void msg_set_conn_ack(struct tipc_msg *m, u32 n) 1026 { 1027 msg_set_bits(m, 9, 16, 0xffff, n); 1028 } 1029 1030 static inline u16 msg_adv_win(struct tipc_msg *m) 1031 { 1032 return msg_bits(m, 9, 0, 0xffff); 1033 } 1034 1035 static inline void msg_set_adv_win(struct tipc_msg *m, u16 n) 1036 { 1037 msg_set_bits(m, 9, 0, 0xffff, n); 1038 } 1039 1040 static inline u32 msg_max_pkt(struct tipc_msg *m) 1041 { 1042 return msg_bits(m, 9, 16, 0xffff) * 4; 1043 } 1044 1045 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n) 1046 { 1047 msg_set_bits(m, 9, 16, 0xffff, (n / 4)); 1048 } 1049 1050 static inline u32 msg_link_tolerance(struct tipc_msg *m) 1051 { 1052 return msg_bits(m, 9, 0, 0xffff); 1053 } 1054 1055 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n) 1056 { 1057 msg_set_bits(m, 9, 0, 0xffff, n); 1058 } 1059 1060 static inline u16 msg_grp_bc_syncpt(struct tipc_msg *m) 1061 { 1062 return msg_bits(m, 9, 16, 0xffff); 1063 } 1064 1065 static inline void msg_set_grp_bc_syncpt(struct tipc_msg *m, u16 n) 1066 { 1067 msg_set_bits(m, 9, 16, 0xffff, n); 1068 } 1069 1070 static inline u16 msg_grp_bc_acked(struct tipc_msg *m) 1071 { 1072 return msg_bits(m, 9, 16, 0xffff); 1073 } 1074 1075 static inline void msg_set_grp_bc_acked(struct tipc_msg *m, u16 n) 1076 { 1077 msg_set_bits(m, 9, 16, 0xffff, n); 1078 } 1079 1080 static inline u16 msg_grp_remitted(struct tipc_msg *m) 1081 { 1082 return msg_bits(m, 9, 16, 0xffff); 1083 } 1084 1085 static inline void msg_set_grp_remitted(struct tipc_msg *m, u16 n) 1086 { 1087 msg_set_bits(m, 9, 16, 0xffff, n); 1088 } 1089 1090 /* Word 10 1091 */ 1092 static inline u16 msg_grp_evt(struct tipc_msg *m) 1093 { 1094 return msg_bits(m, 10, 0, 0x3); 1095 } 1096 1097 static inline void msg_set_grp_evt(struct tipc_msg *m, int n) 1098 { 1099 msg_set_bits(m, 10, 0, 0x3, n); 1100 } 1101 1102 static inline u16 msg_grp_bc_ack_req(struct tipc_msg *m) 1103 { 1104 return msg_bits(m, 10, 0, 0x1); 1105 } 1106 1107 static inline void msg_set_grp_bc_ack_req(struct tipc_msg *m, bool n) 1108 { 1109 msg_set_bits(m, 10, 0, 0x1, n); 1110 } 1111 1112 static inline u16 msg_grp_bc_seqno(struct tipc_msg *m) 1113 { 1114 return msg_bits(m, 10, 16, 0xffff); 1115 } 1116 1117 static inline void msg_set_grp_bc_seqno(struct tipc_msg *m, u32 n) 1118 { 1119 msg_set_bits(m, 10, 16, 0xffff, n); 1120 } 1121 1122 static inline bool msg_peer_link_is_up(struct tipc_msg *m) 1123 { 1124 if (likely(msg_user(m) != LINK_PROTOCOL)) 1125 return true; 1126 if (msg_type(m) == STATE_MSG) 1127 return true; 1128 return false; 1129 } 1130 1131 static inline bool msg_peer_node_is_up(struct tipc_msg *m) 1132 { 1133 if (msg_peer_link_is_up(m)) 1134 return true; 1135 return msg_redundant_link(m); 1136 } 1137 1138 static inline bool msg_is_reset(struct tipc_msg *hdr) 1139 { 1140 return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG); 1141 } 1142 1143 /* Word 13 1144 */ 1145 static inline void msg_set_peer_net_hash(struct tipc_msg *m, u32 n) 1146 { 1147 msg_set_word(m, 13, n); 1148 } 1149 1150 static inline u32 msg_peer_net_hash(struct tipc_msg *m) 1151 { 1152 return msg_word(m, 13); 1153 } 1154 1155 /* Word 14 1156 */ 1157 static inline u32 msg_sugg_node_addr(struct tipc_msg *m) 1158 { 1159 return msg_word(m, 14); 1160 } 1161 1162 static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n) 1163 { 1164 msg_set_word(m, 14, n); 1165 } 1166 1167 static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id) 1168 { 1169 memcpy(msg_data(hdr), id, 16); 1170 } 1171 1172 static inline u8 *msg_node_id(struct tipc_msg *hdr) 1173 { 1174 return (u8 *)msg_data(hdr); 1175 } 1176 1177 struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp); 1178 bool tipc_msg_validate(struct sk_buff **_skb); 1179 bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err); 1180 void tipc_skb_reject(struct net *net, int err, struct sk_buff *skb, 1181 struct sk_buff_head *xmitq); 1182 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type, 1183 u32 hsize, u32 destnode); 1184 struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz, 1185 uint data_sz, u32 dnode, u32 onode, 1186 u32 dport, u32 oport, int errcode); 1187 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf); 1188 bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss, 1189 u32 dnode, bool *new_bundle); 1190 bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos); 1191 int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr, 1192 int pktmax, struct sk_buff_head *frags); 1193 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, 1194 int offset, int dsz, int mtu, struct sk_buff_head *list); 1195 int tipc_msg_append(struct tipc_msg *hdr, struct msghdr *m, int dlen, 1196 int mss, struct sk_buff_head *txq); 1197 bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err); 1198 bool tipc_msg_assemble(struct sk_buff_head *list); 1199 bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq); 1200 bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg, 1201 struct sk_buff_head *cpy); 1202 bool __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno, 1203 struct sk_buff *skb); 1204 bool tipc_msg_skb_clone(struct sk_buff_head *msg, struct sk_buff_head *cpy); 1205 1206 static inline u16 buf_seqno(struct sk_buff *skb) 1207 { 1208 return msg_seqno(buf_msg(skb)); 1209 } 1210 1211 static inline int buf_roundup_len(struct sk_buff *skb) 1212 { 1213 return (skb->len / 1024 + 1) * 1024; 1214 } 1215 1216 /* tipc_skb_peek(): peek and reserve first buffer in list 1217 * @list: list to be peeked in 1218 * Returns pointer to first buffer in list, if any 1219 */ 1220 static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list, 1221 spinlock_t *lock) 1222 { 1223 struct sk_buff *skb; 1224 1225 spin_lock_bh(lock); 1226 skb = skb_peek(list); 1227 if (skb) 1228 skb_get(skb); 1229 spin_unlock_bh(lock); 1230 return skb; 1231 } 1232 1233 /* tipc_skb_peek_port(): find a destination port, ignoring all destinations 1234 * up to and including 'filter'. 1235 * Note: ignoring previously tried destinations minimizes the risk of 1236 * contention on the socket lock 1237 * @list: list to be peeked in 1238 * @filter: last destination to be ignored from search 1239 * Returns a destination port number, of applicable. 1240 */ 1241 static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter) 1242 { 1243 struct sk_buff *skb; 1244 u32 dport = 0; 1245 bool ignore = true; 1246 1247 spin_lock_bh(&list->lock); 1248 skb_queue_walk(list, skb) { 1249 dport = msg_destport(buf_msg(skb)); 1250 if (!filter || skb_queue_is_last(list, skb)) 1251 break; 1252 if (dport == filter) 1253 ignore = false; 1254 else if (!ignore) 1255 break; 1256 } 1257 spin_unlock_bh(&list->lock); 1258 return dport; 1259 } 1260 1261 /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list 1262 * @list: list to be unlinked from 1263 * @dport: selection criteria for buffer to unlink 1264 */ 1265 static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list, 1266 u32 dport) 1267 { 1268 struct sk_buff *_skb, *tmp, *skb = NULL; 1269 1270 spin_lock_bh(&list->lock); 1271 skb_queue_walk_safe(list, _skb, tmp) { 1272 if (msg_destport(buf_msg(_skb)) == dport) { 1273 __skb_unlink(_skb, list); 1274 skb = _skb; 1275 break; 1276 } 1277 } 1278 spin_unlock_bh(&list->lock); 1279 return skb; 1280 } 1281 1282 /* tipc_skb_queue_splice_tail - append an skb list to lock protected list 1283 * @list: the new list to append. Not lock protected 1284 * @head: target list. Lock protected. 1285 */ 1286 static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list, 1287 struct sk_buff_head *head) 1288 { 1289 spin_lock_bh(&head->lock); 1290 skb_queue_splice_tail(list, head); 1291 spin_unlock_bh(&head->lock); 1292 } 1293 1294 /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists 1295 * @list: the new list to add. Lock protected. Will be reinitialized 1296 * @head: target list. Lock protected. 1297 */ 1298 static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list, 1299 struct sk_buff_head *head) 1300 { 1301 struct sk_buff_head tmp; 1302 1303 __skb_queue_head_init(&tmp); 1304 1305 spin_lock_bh(&list->lock); 1306 skb_queue_splice_tail_init(list, &tmp); 1307 spin_unlock_bh(&list->lock); 1308 tipc_skb_queue_splice_tail(&tmp, head); 1309 } 1310 1311 /* __tipc_skb_dequeue() - dequeue the head skb according to expected seqno 1312 * @list: list to be dequeued from 1313 * @seqno: seqno of the expected msg 1314 * 1315 * returns skb dequeued from the list if its seqno is less than or equal to 1316 * the expected one, otherwise the skb is still hold 1317 * 1318 * Note: must be used with appropriate locks held only 1319 */ 1320 static inline struct sk_buff *__tipc_skb_dequeue(struct sk_buff_head *list, 1321 u16 seqno) 1322 { 1323 struct sk_buff *skb = skb_peek(list); 1324 1325 if (skb && less_eq(buf_seqno(skb), seqno)) { 1326 __skb_unlink(skb, list); 1327 return skb; 1328 } 1329 return NULL; 1330 } 1331 1332 #endif 1333