1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 22/* All Rights Reserved */ 23 24 25/* 26 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 27 */ 28 29#ifndef _SYS_TIHDR_H 30#define _SYS_TIHDR_H 31 32#include <sys/types.h> 33/* 34 * Include declarations implicit to TPI and shared with user level code 35 */ 36#include <sys/tpicommon.h> 37 38#ifdef __cplusplus 39extern "C" { 40#endif 41 42/* 43 * The feature test macro, _SUN_TPI_VERSION makes some of additional 44 * declarations available and changes some existing ones. There was 45 * some changes done to this interface and this feature test macro 46 * enables transitioning to those changes while maintaining retaining 47 * backward compatibility. 48 * 49 * The following is all the information 50 * needed by the Transport Service Interface. 51 */ 52 53/* 54 * The following are the definitions of the Transport 55 * Service Interface primitives. 56 */ 57 58/* 59 * Primitives that are initiated by the transport user. 60 */ 61#define T_CONN_REQ 0 /* connection request */ 62#if _SUN_TPI_VERSION > 1 63#define O_T_CONN_RES 1 /* old connection response */ 64#else 65#define T_CONN_RES 1 /* connection response */ 66#endif /* _SUN_TPI_VERSION > 1 */ 67#define T_DISCON_REQ 2 /* disconnect request */ 68#define T_DATA_REQ 3 /* data request */ 69#define T_EXDATA_REQ 4 /* expedited data request */ 70#define T_INFO_REQ 5 /* information request */ 71/* 72 * Bind Request primitive (TLI inspired 73 * address binding semantics). If requested address is 74 * found to be busy, an alternative free address is 75 * returned. (Requires comparison of requested address to 76 * returned address to verify if the requested address was 77 * bound) 78 * 79 */ 80#if _SUN_TPI_VERSION > 0 81#define O_T_BIND_REQ 6 82#else 83#define T_BIND_REQ 6 84#endif /* _SUN_TPI_VERSION > 0 */ 85 86#define T_UNBIND_REQ 7 /* unbind request */ 87#define T_UNITDATA_REQ 8 /* unitdata request */ 88 89/* 90 * Option management request (with TLI inspired semantics ) 91 * The preferred name for this primitive in new code is T_SVR4_OPTMGMT_REQ. 92 * This primitive had the name T_OPTMGMT_REQ in old SVR4 derived TPI. 93 * This primitive is used for TLI and Socket API support. 94 * The packing of options in option buffer is private contract 95 * between transport provider and its users and can differ 96 * between different transports. 97 * (The name O_T_OPTMGMT_REQ continues to exist for Solaris 2.6 98 * compilation environment compatibility only) 99 * 100 */ 101#define T_SVR4_OPTMGMT_REQ 9 102#if _SUN_TPI_VERSION > 0 103#define O_T_OPTMGMT_REQ T_SVR4_OPTMGMT_REQ 104#else 105#define T_OPTMGMT_REQ T_SVR4_OPTMGMT_REQ 106#endif /* _SUN_TPI_VERSION > 0 */ 107 108#define T_ORDREL_REQ 10 /* orderly release req */ 109 110/* 111 * Primitives that are initiated by the transport provider. 112 */ 113#define T_CONN_IND 11 /* connection indication */ 114#define T_CONN_CON 12 /* connection confirmation */ 115#define T_DISCON_IND 13 /* disconnect indication */ 116#define T_DATA_IND 14 /* data indication */ 117#define T_EXDATA_IND 15 /* expeditied data indication */ 118#define T_INFO_ACK 16 /* information acknowledgment */ 119#define T_BIND_ACK 17 /* bind acknowledment */ 120#define T_ERROR_ACK 18 /* error acknowledgment */ 121#define T_OK_ACK 19 /* ok acknowledgment */ 122#define T_UNITDATA_IND 20 /* unitdata indication */ 123#define T_UDERROR_IND 21 /* unitdata error indication */ 124#define T_OPTMGMT_ACK 22 /* manage options ack */ 125#define T_ORDREL_IND 23 /* orderly release ind */ 126/* 127 * Primitives added to namespace and contain a mix of ones 128 * initiated by transport user or provider. 129 */ 130#define T_ADDR_REQ 24 /* address request */ 131#define T_ADDR_ACK 25 /* address acknowledgement */ 132 133#if _SUN_TPI_VERSION > 0 134/* 135 * Bind request primitive with better address 136 * binding semantics. (XTI inspired) 137 * If the requested address is found to be busy, 138 * an error is returned. (No need to compare addresses on successful 139 * bind acknowledgement). 140 */ 141#define T_BIND_REQ 26 /* bind request */ 142 143/* 144 * Option management request (with XTI inspired semantics) 145 * The packing of options in option buffer is required to 146 * be with 'struct T_opthdr' data structure defined later in 147 * this header. 148 */ 149#define T_OPTMGMT_REQ 27 /* manage options req - T_opthdr option header */ 150#endif /* _SUN_TPI_VERSION > 0 */ 151 152#if _SUN_TPI_VERSION > 1 153/* 154 * The connection response that expects its ACCEPTOR_id to have been 155 * filled in from the value supplied via a T_CAPABILITY_ACK. 156 */ 157#define T_CONN_RES 28 /* connection response */ 158 159/* 160 * Capability request and ack. These primitives are optional and 161 * subsume the functionality of T_INFO_{REQ,ACK}. 162 */ 163#define T_CAPABILITY_REQ 30 164#define T_CAPABILITY_ACK 31 165#endif /* _SUN_TPI_VERSION > 1 */ 166 167#ifdef _KERNEL 168/* 169 * Sun private TPI extensions. They are currently used for transparently 170 * passing options through the connection-oriented loopback transport. 171 * Values assigned to them may change. 172 * 173 * T_EXTCONN_IND (extended T_CONN_IND) is used to return dst as well as 174 * src addr/port. 175 */ 176#define T_OPTDATA_REQ 0x1001 /* data (with options) request */ 177#define T_OPTDATA_IND 0x1002 /* data (with options) indication */ 178#define T_EXTCONN_IND 0x1003 /* extended T_CONN_IND to return dst as well */ 179 180#endif /* _KERNEL */ 181 182/* 183 * The following are the events that drive the state machine 184 */ 185/* Initialization events */ 186#define TE_BIND_REQ 0 /* bind request */ 187#define TE_UNBIND_REQ 1 /* unbind request */ 188#define TE_OPTMGMT_REQ 2 /* manage options req */ 189#define TE_BIND_ACK 3 /* bind acknowledment */ 190#define TE_OPTMGMT_ACK 4 /* manage options ack */ 191#define TE_ERROR_ACK 5 /* error acknowledgment */ 192#define TE_OK_ACK1 6 /* ok ack seqcnt == 0 */ 193#define TE_OK_ACK2 7 /* ok ack seqcnt == 1, q == resq */ 194#define TE_OK_ACK3 8 /* ok ack seqcnt == 1, q != resq */ 195#define TE_OK_ACK4 9 /* ok ack seqcnt > 1 */ 196 197/* Connection oriented events */ 198#define TE_CONN_REQ 10 /* connection request */ 199#define TE_CONN_RES 11 /* connection response */ 200#define TE_DISCON_REQ 12 /* disconnect request */ 201#define TE_DATA_REQ 13 /* data request */ 202#define TE_EXDATA_REQ 14 /* expedited data request */ 203#define TE_ORDREL_REQ 15 /* orderly release req */ 204#define TE_CONN_IND 16 /* connection indication */ 205#define TE_CONN_CON 17 /* connection confirmation */ 206#define TE_DATA_IND 18 /* data indication */ 207#define TE_EXDATA_IND 19 /* expedited data indication */ 208#define TE_ORDREL_IND 20 /* orderly release ind */ 209#define TE_DISCON_IND1 21 /* disconnect indication seq == 0 */ 210#define TE_DISCON_IND2 22 /* disconnect indication seq == 1 */ 211#define TE_DISCON_IND3 23 /* disconnect indication seq > 1 */ 212#define TE_PASS_CONN 24 /* pass connection */ 213 214/* Unit data events */ 215#define TE_UNITDATA_REQ 25 /* unitdata request */ 216#define TE_UNITDATA_IND 26 /* unitdata indication */ 217#define TE_UDERROR_IND 27 /* unitdata error indication */ 218 219#define TE_NOEVENTS 28 220/* 221 * The following are the possible states of the Transport 222 * Service Interface 223 */ 224 225#define TS_UNBND 0 /* unbound */ 226#define TS_WACK_BREQ 1 /* waiting ack of BIND_REQ */ 227#define TS_WACK_UREQ 2 /* waiting ack of UNBIND_REQ */ 228#define TS_IDLE 3 /* idle */ 229#define TS_WACK_OPTREQ 4 /* wait ack options request */ 230#define TS_WACK_CREQ 5 /* waiting ack of CONN_REQ */ 231#define TS_WCON_CREQ 6 /* waiting confirm of CONN_REQ */ 232#define TS_WRES_CIND 7 /* waiting response of CONN_IND */ 233#define TS_WACK_CRES 8 /* waiting ack of CONN_RES */ 234#define TS_DATA_XFER 9 /* data transfer */ 235#define TS_WIND_ORDREL 10 /* releasing rd but not wr */ 236#define TS_WREQ_ORDREL 11 /* wait to release wr but not rd */ 237#define TS_WACK_DREQ6 12 /* waiting ack of DISCON_REQ */ 238#define TS_WACK_DREQ7 13 /* waiting ack of DISCON_REQ */ 239#define TS_WACK_DREQ9 14 /* waiting ack of DISCON_REQ */ 240#define TS_WACK_DREQ10 15 /* waiting ack of DISCON_REQ */ 241#define TS_WACK_DREQ11 16 /* waiting ack of DISCON_REQ */ 242 243#define TS_NOSTATES 17 244 245 246/* 247 * The following structure definitions define the format of the 248 * stream message block of the above primitives. 249 * (everything is declared t_scalar_t to ensure proper alignment 250 * across different machines) 251 */ 252 253/* connection request */ 254 255struct T_conn_req { 256 t_scalar_t PRIM_type; /* always T_CONN_REQ */ 257 t_scalar_t DEST_length; /* dest addr length */ 258 t_scalar_t DEST_offset; /* dest addr offset */ 259 t_scalar_t OPT_length; /* options length */ 260 t_scalar_t OPT_offset; /* options offset */ 261}; 262 263/* connect response */ 264 265/* 266 * Historical compatibility note for "struct T_conn_res" usage. 267 * "QUEUE_ptr" field of type "queue_t" is obsolete to support 268 * code portability and application binary compatibility 269 * between ILP32(32-bit) and LP64 (64-bit) environments. 270 * Use field "ACCEPTOR_id" instead. 271 * For compatibility, drivers using (_SUN_TPI_VERSION >= 2) interface 272 * can support treating ACCEPTOR_id content as queue pointer 273 * only when PRIM_type is O_T_CONN_RES. 274 */ 275struct T_conn_res { 276 t_scalar_t PRIM_type; /* T_CONN_RES (or O_T_CONN_RES) */ 277 t_uscalar_t ACCEPTOR_id; /* id of accepting endpoint */ 278 t_scalar_t OPT_length; /* options length */ 279 t_scalar_t OPT_offset; /* options offset */ 280 t_scalar_t SEQ_number; /* sequence number */ 281}; 282 283/* disconnect request */ 284 285struct T_discon_req { 286 t_scalar_t PRIM_type; /* always T_DISCON_REQ */ 287 t_scalar_t SEQ_number; /* sequnce number */ 288}; 289 290/* data request */ 291 292struct T_data_req { 293 t_scalar_t PRIM_type; /* always T_DATA_REQ */ 294 t_scalar_t MORE_flag; /* more data */ 295}; 296 297/* expedited data request */ 298 299struct T_exdata_req { 300 t_scalar_t PRIM_type; /* always T_EXDATA_REQ */ 301 t_scalar_t MORE_flag; /* more data */ 302}; 303 304/* information request */ 305 306struct T_info_req { 307 t_scalar_t PRIM_type; /* always T_INFO_REQ */ 308}; 309 310/* bind request */ 311 312struct T_bind_req { 313 t_scalar_t PRIM_type; /* T_BIND_REQ (or O_T_BIND_REQ) */ 314 t_scalar_t ADDR_length; /* addr length */ 315 t_scalar_t ADDR_offset; /* addr offset */ 316 t_uscalar_t CONIND_number; /* connect indications requested */ 317}; 318 319/* unbind request */ 320 321struct T_unbind_req { 322 t_scalar_t PRIM_type; /* always T_UNBIND_REQ */ 323}; 324 325/* unitdata request */ 326 327struct T_unitdata_req { 328 t_scalar_t PRIM_type; /* always T_UNITDATA_REQ */ 329 t_scalar_t DEST_length; /* dest addr length */ 330 t_scalar_t DEST_offset; /* dest addr offset */ 331 t_scalar_t OPT_length; /* options length */ 332 t_scalar_t OPT_offset; /* options offset */ 333}; 334 335/* manage options request */ 336 337struct T_optmgmt_req { 338 t_scalar_t PRIM_type; /* T_OPTMGMT_REQ or */ 339 /* T_SVR4_OPTMGMT_REQ */ 340 t_scalar_t OPT_length; /* options length */ 341 t_scalar_t OPT_offset; /* options offset */ 342 t_scalar_t MGMT_flags; /* options flags */ 343}; 344 345/* orderly release request */ 346 347struct T_ordrel_req { 348 t_scalar_t PRIM_type; /* always T_ORDREL_REQ */ 349}; 350 351/* protocol address request */ 352 353struct T_addr_req { 354 t_scalar_t PRIM_type; /* always T_ADDR_REQ */ 355}; 356 357/* connect indication */ 358 359struct T_conn_ind { 360 t_scalar_t PRIM_type; /* always T_CONN_IND */ 361 t_scalar_t SRC_length; /* src addr length */ 362 t_scalar_t SRC_offset; /* src addr offset */ 363 t_scalar_t OPT_length; /* option length */ 364 t_scalar_t OPT_offset; /* option offset */ 365 t_scalar_t SEQ_number; /* sequnce number */ 366}; 367 368/* connect confirmation */ 369 370struct T_conn_con { 371 t_scalar_t PRIM_type; /* always T_CONN_CON */ 372 t_scalar_t RES_length; /* responding addr length */ 373 t_scalar_t RES_offset; /* responding addr offset */ 374 t_scalar_t OPT_length; /* option length */ 375 t_scalar_t OPT_offset; /* option offset */ 376}; 377 378/* disconnect indication */ 379 380struct T_discon_ind { 381 t_scalar_t PRIM_type; /* always T_DISCON_IND */ 382 t_scalar_t DISCON_reason; /* disconnect reason */ 383 t_scalar_t SEQ_number; /* sequnce number */ 384}; 385 386/* data indication */ 387 388struct T_data_ind { 389 t_scalar_t PRIM_type; /* always T_DATA_IND */ 390 t_scalar_t MORE_flag; /* more data */ 391}; 392 393/* expedited data indication */ 394 395struct T_exdata_ind { 396 t_scalar_t PRIM_type; /* always T_EXDATA_IND */ 397 t_scalar_t MORE_flag; /* more data */ 398}; 399 400/* information acknowledgment */ 401 402struct T_info_ack { 403 t_scalar_t PRIM_type; /* always T_INFO_ACK */ 404 t_scalar_t TSDU_size; /* max TSDU size */ 405 t_scalar_t ETSDU_size; /* max ETSDU size */ 406 t_scalar_t CDATA_size; /* max connect data size */ 407 t_scalar_t DDATA_size; /* max discon data size */ 408 t_scalar_t ADDR_size; /* address size */ 409 t_scalar_t OPT_size; /* options size */ 410 t_scalar_t TIDU_size; /* max TIDU size */ 411 t_scalar_t SERV_type; /* provider service type */ 412 t_scalar_t CURRENT_state; /* current state */ 413 t_scalar_t PROVIDER_flag; /* provider flags */ 414}; 415 416/* 417 * The following are definitions of flags available to the transport 418 * provider to set in the PROVIDER_flag field of the T_info_ack 419 * structure. 420 */ 421 422#if _SUN_TPI_VERSION > 0 423#define SENDZERO 0x0001 /* provider can handle --length TSDUs */ 424 425#define OLD_SENDZERO 0x1000 /* reserved for compatibility with */ 426 /* old providers- old value of */ 427 /* SENDZERO defined in <sys/timod.h> */ 428#else 429#define SENDZERO 0x1000 /* old SENDZERO value */ 430#endif /* _SUN_TPI_VERSION > 0 */ 431 432#define EXPINLINE 0x0002 /* provider wants ETSDUs in band 0 */ 433/* 434 * Flag XPG4_1: 435 * transport provider supports TPI modifications motivated by and 436 * in conjunction with XTI inspired TPI support and all the 437 * compatibility baggage that implies. 438 * It implies, - primitives T_ADDR_REQ & T_ADDR_ACK supported 439 * - primitives O_T_BIND_REQ & T_BIND_REQ separately supported 440 * - primitives T_SVR4_OPTMGMT_REQ & T_OPTMGMT_REQ separately 441 * supported. 442 */ 443#define XPG4_1 0x0004 444 445/* bind acknowledgment */ 446 447struct T_bind_ack { 448 t_scalar_t PRIM_type; /* always T_BIND_ACK */ 449 t_scalar_t ADDR_length; /* addr length */ 450 t_scalar_t ADDR_offset; /* addr offset */ 451 t_uscalar_t CONIND_number; /* connect ind to be queued */ 452}; 453 454/* error acknowledgment */ 455 456struct T_error_ack { 457 t_scalar_t PRIM_type; /* always T_ERROR_ACK */ 458 t_scalar_t ERROR_prim; /* primitive in error */ 459 t_scalar_t TLI_error; /* TLI error code */ 460 t_scalar_t UNIX_error; /* UNIX error code */ 461}; 462 463/* ok acknowledgment */ 464 465struct T_ok_ack { 466 t_scalar_t PRIM_type; /* always T_OK_ACK */ 467 t_scalar_t CORRECT_prim; /* correct primitive */ 468}; 469 470/* unitdata indication */ 471 472struct T_unitdata_ind { 473 t_scalar_t PRIM_type; /* always T_UNITDATA_IND */ 474 t_scalar_t SRC_length; /* source addr length */ 475 t_scalar_t SRC_offset; /* source addr offset */ 476 t_scalar_t OPT_length; /* options length */ 477 t_scalar_t OPT_offset; /* options offset */ 478}; 479 480/* unitdata error indication */ 481 482struct T_uderror_ind { 483 t_scalar_t PRIM_type; /* always T_UDERROR_IND */ 484 t_scalar_t DEST_length; /* dest addr length */ 485 t_scalar_t DEST_offset; /* dest addr offset */ 486 t_scalar_t OPT_length; /* options length */ 487 t_scalar_t OPT_offset; /* options offset */ 488 t_scalar_t ERROR_type; /* error type */ 489}; 490 491/* manage options ack */ 492 493struct T_optmgmt_ack { 494 t_scalar_t PRIM_type; /* always T_OPTMGMT_ACK */ 495 t_scalar_t OPT_length; /* options length */ 496 t_scalar_t OPT_offset; /* options offset */ 497 t_scalar_t MGMT_flags; /* managment flags */ 498}; 499 500/* orderly release indication */ 501 502struct T_ordrel_ind { 503 t_scalar_t PRIM_type; /* always T_ORDREL_IND */ 504}; 505 506 507/* protocol address acknowledgment */ 508 509struct T_addr_ack { 510 t_scalar_t PRIM_type; /* always T_ADDR_ACK */ 511 t_scalar_t LOCADDR_length; /* length of local address */ 512 t_scalar_t LOCADDR_offset; /* offset of local address */ 513 t_scalar_t REMADDR_length; /* length of remote address */ 514 t_scalar_t REMADDR_offset; /* offset of remote address */ 515}; 516 517#if _SUN_TPI_VERSION > 1 518/* 519 * Capability request and ack. These primitives are optional and 520 * subsume the functionality of T_INFO_{REQ,ACK}. 521 */ 522struct T_capability_req { 523 t_scalar_t PRIM_type; /* always T_CAPABILITY_REQ */ 524 t_uscalar_t CAP_bits1; /* capability bits #1 */ 525}; 526 527struct T_capability_ack { 528 t_scalar_t PRIM_type; /* always T_CAPABILITY_ACK */ 529 t_uscalar_t CAP_bits1; /* capability bits #1 */ 530 struct T_info_ack 531 INFO_ack; /* info acknowledgement */ 532 t_uscalar_t ACCEPTOR_id; /* accepting endpoint id */ 533}; 534 535#define TC1_INFO (1u << 0) /* Info request/ack */ 536#define TC1_ACCEPTOR_ID (1u << 1) /* Acceptor_id request/ack */ 537#define TC1_CAP_BITS2 (1u << 31) /* Reserved for future use */ 538 539#endif /* _SUN_TPI_VERSION > 1 */ 540 541#ifdef _KERNEL 542/* 543 * Private Sun TPI extensions. 544 */ 545 546/* data (with options) request */ 547struct T_optdata_req { 548 t_scalar_t PRIM_type; /* always T_OPTDATA_REQ */ 549 t_scalar_t DATA_flag; /* flags like "more data" */ 550 t_scalar_t OPT_length; /* options length */ 551 t_scalar_t OPT_offset; /* options offset */ 552}; 553 554/* data (with options) indication */ 555struct T_optdata_ind { 556 t_scalar_t PRIM_type; /* always T_OPTDATA_IND */ 557 t_scalar_t DATA_flag; /* flags like "more data" */ 558 t_scalar_t OPT_length; /* options length */ 559 t_scalar_t OPT_offset; /* options offset */ 560}; 561 562/* extended connect indication to return dst addr/port as well as src */ 563struct T_extconn_ind { 564 t_scalar_t PRIM_type; /* always T_EXTCONN_IND */ 565 t_scalar_t SRC_length; /* src addr length */ 566 t_scalar_t SRC_offset; /* src addr offset */ 567 t_scalar_t OPT_length; /* option length */ 568 t_scalar_t OPT_offset; /* option offset */ 569 t_scalar_t SEQ_number; /* sequnce number */ 570 t_scalar_t DEST_length; /* dest addr length */ 571 t_scalar_t DEST_offset; /* dest addr offset */ 572}; 573#endif /* _KERNEL */ 574 575/* 576 * The following is a union of the primitives 577 */ 578union T_primitives { 579 t_scalar_t type; /* primitive type */ 580 struct T_conn_req conn_req; /* connect request */ 581 struct T_conn_res conn_res; /* connect response */ 582 struct T_discon_req discon_req; /* disconnect request */ 583 struct T_data_req data_req; /* data request */ 584 struct T_exdata_req exdata_req; /* expedited data req */ 585 struct T_info_req info_req; /* information req */ 586 struct T_bind_req bind_req; /* bind request */ 587 struct T_unbind_req unbind_req; /* unbind request */ 588 struct T_unitdata_req unitdata_req; /* unitdata requset */ 589 struct T_optmgmt_req optmgmt_req; /* manage opt req */ 590 struct T_ordrel_req ordrel_req; /* orderly rel req */ 591 struct T_addr_req addr_req; /* address request */ 592 struct T_conn_ind conn_ind; /* connect indication */ 593 struct T_conn_con conn_con; /* connect corfirm */ 594 struct T_discon_ind discon_ind; /* discon indication */ 595 struct T_data_ind data_ind; /* data indication */ 596 struct T_exdata_ind exdata_ind; /* expedited data ind */ 597 struct T_info_ack info_ack; /* info ack */ 598 struct T_bind_ack bind_ack; /* bind ack */ 599 struct T_error_ack error_ack; /* error ack */ 600 struct T_ok_ack ok_ack; /* ok ack */ 601 struct T_unitdata_ind unitdata_ind; /* unitdata ind */ 602 struct T_uderror_ind uderror_ind; /* unitdata error ind */ 603 struct T_optmgmt_ack optmgmt_ack; /* manage opt ack */ 604 struct T_ordrel_ind ordrel_ind; /* orderly rel ind */ 605 struct T_addr_ack addr_ack; /* address ack */ 606#if _SUN_TPI_VERSION > 1 607 struct T_capability_req capability_req; /* capability req */ 608 struct T_capability_ack capability_ack; /* capability ack */ 609#endif /* _SUN_TPI_VERSION > 1 */ 610#ifdef _KERNEL 611 struct T_optdata_req optdata_req; /* option data request */ 612 struct T_optdata_ind optdata_ind; /* option data ind */ 613 struct T_extconn_ind extconn_ind; /* above plus dst addr */ 614#endif /* _KERNEL */ 615}; 616 617/* 618 * TPI specification is not clear on how to pack options in option 619 * buffers. What follows is the Solaris TPI interpretation of it. 620 * 621 * struct T_opthdr data structure is used to pack options in T_OPTMGMT_{REQ,ACK} 622 * message primitives in buffer delimited by [OPT_offset, OPT_length] fields in 623 * struct T_optmgmt_req/T_optmgmt_ack data structures. 624 * 625 * It is also used to pack options in similar buffers for data structures in 626 * T_CONN_{REQ,IND,RES,CONN} primitives and T_UNITDATA_{REQ,IND} primitives 627 * Needs to be on t_uscalar_t (32-bit word) aligned boundary. 628 * 629 * Note: T_SVR4_OPTMGMT_REQ primitive can, but need not, use this data 630 * structure for packing options. The format of option buffer for 631 * T_SVR4_OPTMGMT_REQ primitive is undefined and is a private contract 632 * between transport provider and its users. 633 * 634 * |<--------------first option---------------->| |<--second option--... 635 * ______________________________________ _ _ _ ____________________________ 636 * | len | level | name | status | value.......| / / | len ... 637 * -------------------------------------- - - - ---------------------------- 638 * |32bit| 32bit |32bit | 32bit | ^ | 32bit... 639 * | 640 * | 641 * alignment characters 642 */ 643struct T_opthdr { 644 t_uscalar_t len; /* total length of option (header+value) */ 645 t_uscalar_t level; /* protocol level */ 646 t_uscalar_t name; /* option name */ 647 t_uscalar_t status; /* status value */ 648 /* option value aligned on t_uscalar_t (32-bit) alignment boundary */ 649}; 650 651/* 652 * ------------------------------------------------------------------------ 653 * Common experimental private TPI alignment related macros. Not for 654 * use outside Solaris bundled code and can change in any release. 655 * The alignment boundary _TPI_ALIGN_SIZE represents an implementation 656 * choice for aligning many data objects which are directly or indirectly 657 * associated with Solaris TPI implementation. 658 * ------------------------------------------------------------------------ 659 */ 660 661#define __TPI_ALIGN_SIZE (sizeof (t_scalar_t)) 662#define __TPI_ALIGN(x) \ 663 (((uintptr_t)(x) + __TPI_ALIGN_SIZE - 1) & ~(__TPI_ALIGN_SIZE - 1)) 664#define __TPI_SIZE_ISALIGNED(x) \ 665 (((uintptr_t)(x) & (__TPI_ALIGN_SIZE - 1)) == 0) 666 667/* 668 * TPI primitive in message must be aligned at _TPI_ALIGN_SIZE boundary 669 */ 670#define __TPI_PRIM_ISALIGNED(x) __TPI_SIZE_ISALIGNED(x) 671 672/* 673 * TPI option header "struct opthdr" objects must be aligned 674 * at __TPI_ALIGN_SIZE boundary. 675 */ 676#define __TPI_OPT_ISALIGNED(x) __TPI_SIZE_ISALIGNED(x) 677#define _TPI_ALIGN_OPT(x) __TPI_ALIGN(x) 678 679/* 680 * TPI option header "struct T_opthdr" objects must be aligned 681 * at __TPI_ALIGN_SIZE boundary. 682 */ 683#define __TPI_TOPT_ISALIGNED(x) __TPI_SIZE_ISALIGNED(x) 684#define _TPI_ALIGN_TOPT(x) __TPI_ALIGN(x) 685 686/* 687 * -------------------------------------------------------------------- 688 * Private experimental macros. Not for use outside Solaris bundled 689 * source code and can change in any release. 690 * Macros that operate on struct T_opthdr. These are roughly modelled 691 * after the corresponding Socket CMSG_*() and XTI T_OPT_*() macros, but 692 * are applied to TPI option buffers. 693 * -------------------------------------------------------------------- 694 * 695 * unsigned char * 696 * _TPI_TOPT_DATA(struct T_opthdr *tohp): 697 * Get start of data part after option header 698 */ 699#define _TPI_TOPT_DATA(tohp) \ 700 ((unsigned char *)((char *)(tohp) + sizeof (struct T_opthdr))) 701 702/* 703 * t_uscalar_t 704 * _TPI_TOPT_DATALEN(tohp) 705 * Get length of contents of option data excluding header (and 706 * padding etc if any). 707 */ 708#define _TPI_TOPT_DATALEN(tohp) ((tohp)->len - sizeof (struct T_opthdr)) 709 710/* 711 * struct T_opthdr * 712 * _TPI_TOPT_FIRSTHDR(char *pbuf, t_scalar_t buflen): 713 * Get pointer to the first option header in buffer 'pbuf' 714 * Return NULL if there is not enough room for the header 715 * 716 * struct T_opthdr * 717 * _TPI_TOPT_NEXTHDR(char *pbuf, t_scalar_t buflen, 718 * struct T_opthdr *popt): 719 * Skip to next option header 720 * 721 * Notes: _TPI_TOPT_NEXTHDR performs the roundup of the length. 722 * 723 * If _TPI_TOPT_{FIRST,NEXT}HDR returns a non-null value, the user of 724 * _TPI_TOPT_{FIRST,NEXT}HDR must still verify that the resulting pointer 725 * is valid, by making a call to _TPI_TOPT_VALID. The _TPI_TOPT_VALID 726 * macro does not assume that the last option buffer is padded. 727 */ 728#define _TPI_TOPT_FIRSTHDR(pbuf, buflen) \ 729 ((((buflen) >= (unsigned int) sizeof (struct T_opthdr)) && \ 730 __TPI_TOPT_ISALIGNED(pbuf)) ? \ 731 (struct T_opthdr *)(pbuf) : (struct T_opthdr *)0) 732 733#define _TPI_TOPT_NEXTHDR(pbuf, buflen, popt) \ 734 (((char *)(popt) + _TPI_ALIGN_TOPT((popt)->len)) < \ 735 ((char *)(pbuf) + (buflen)) ? \ 736 (struct T_opthdr *)((char *)(popt) + _TPI_ALIGN_TOPT((popt)->len)) : \ 737 (struct T_opthdr *)0) 738 739/* 740 * bool_t 741 * _TPI_TOPT_VALID(struct T_opthdr *tohp, char *start, char *end) 742 * Validate the option header at tohp, for its alignment and length. 743 * 1. check that tohp is aligned at t_scalar_t boundary 744 * 2. check that start <= tohp < end 745 * 3. validate the length, should be >= sizeof(T_opthdr) and 746 * check that there is no pointer arithmetic overflow. 747 * (could be caused by a very large value for tohp->len) 748 */ 749 750#define _TPI_TOPT_VALID(tohp, start, end) \ 751 (__TPI_TOPT_ISALIGNED(tohp) && \ 752 ((uintptr_t)(tohp) >= (uintptr_t)(start)) && \ 753 ((uintptr_t)(tohp) < (uintptr_t)(end)) && \ 754 ((ssize_t)(tohp)->len >= sizeof (struct T_opthdr)) && \ 755 ((uintptr_t)(tohp) + (tohp)->len <= (uintptr_t)(end)) && \ 756 ((uintptr_t)(tohp) + (tohp)->len >= (uintptr_t)(tohp) + \ 757 sizeof (struct T_opthdr))) 758 759#ifdef __cplusplus 760} 761#endif 762 763#endif /* _SYS_TIHDR_H */ 764