usr/src/uts/common/sys/tihdr.h

   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
  39 extern "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
 255 struct 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  */
 275 struct 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
 285 struct 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
 292 struct 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
 299 struct 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
 306 struct T_info_req {
 307         t_scalar_t      PRIM_type;      /* always T_INFO_REQ            */
 308 };
 309
 310 /* bind request */
 311
 312 struct 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
 321 struct T_unbind_req {
 322         t_scalar_t      PRIM_type;      /* always T_UNBIND_REQ          */
 323 };
 324
 325 /* unitdata request */
 326
 327 struct 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
 337 struct 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
 347 struct T_ordrel_req {
 348         t_scalar_t      PRIM_type;      /* always T_ORDREL_REQ          */
 349 };
 350
 351 /* protocol address request */
 352
 353 struct T_addr_req {
 354         t_scalar_t      PRIM_type;      /* always T_ADDR_REQ            */
 355 };
 356
 357 /* connect indication */
 358
 359 struct 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
 370 struct 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
 380 struct 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
 388 struct 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
 395 struct 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
 402 struct 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
 447 struct 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
 456 struct 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
 465 struct 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
 472 struct 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
 482 struct 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
 493 struct 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
 502 struct T_ordrel_ind {
 503         t_scalar_t      PRIM_type;      /* always T_ORDREL_IND          */
 504 };
 505
 506
 507 /* protocol address acknowledgment */
 508
 509 struct 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  */
 522 struct T_capability_req {
 523         t_scalar_t      PRIM_type;      /* always T_CAPABILITY_REQ      */
 524         t_uscalar_t     CAP_bits1;      /* capability bits #1           */
 525 };
 526
 527 struct 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 */
 547 struct 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 */
 555 struct 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 */
 563 struct 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  */
 578 union 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  */
 643 struct 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 */