usr/src/lib/libc/port/nsl/t_bind.c

   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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22
  23 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  24 /*        All Rights Reserved   */
  25
  26 /*
  27  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"        /* SVr4.0 1.3.4.1 */
  32
  33 #include "mt.h"
  34 #include <stdlib.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <stropts.h>
  38 #include <sys/stream.h>
  39 #define _SUN_TPI_VERSION 2
  40 #include <sys/tihdr.h>
  41 #include <sys/timod.h>
  42 #include <xti.h>
  43 #include <signal.h>
  44 #include <syslog.h>
  45 #include "tx.h"
  46
  47 int
  48 _tx_bind(
  49         int fd,
  50         const struct t_bind *req,
  51         struct t_bind *ret,
  52         int api_semantics
  53 )
  54 {
  55         struct T_bind_req *bind_reqp;
  56         struct T_bind_ack *bind_ackp;
  57         int size, sv_errno, retlen;
  58         struct _ti_user *tiptr;
  59         sigset_t mask;
  60
  61         int didalloc;
  62         int use_xpg41tpi;
  63         struct strbuf ctlbuf;
  64
  65         if ((tiptr = _t_checkfd(fd, 0, api_semantics)) == NULL)
  66                 return (-1);
  67
  68         /*
  69          * We block all signals since TI_BIND, which sends a TPI message
  70          * O_T_BIND_REQ down, is not an idempotetent operation
  71          * Note that sig_mutex_lock() only defers signals, it does not
  72          * block them, so interruptible syscalls could still get EINTR.
  73          */
  74         (void) thr_sigsetmask(SIG_SETMASK, &fillset, &mask);
  75         sig_mutex_lock(&tiptr->ti_lock);
  76         if (_T_IS_XTI(api_semantics)) {
  77                 /*
  78                  * User level state verification only done for XTI
  79                  * because doing for TLI may break existing applications
  80                  */
  81                 if (tiptr->ti_state != T_UNBND) {
  82                         t_errno = TOUTSTATE;
  83                         sig_mutex_unlock(&tiptr->ti_lock);
  84                         (void) thr_sigsetmask(SIG_SETMASK, &mask, NULL);
  85                         return (-1);
  86                 }
  87         }
  88         /*
  89          * Acquire buffer for use in sending/receiving the message.
  90          * Note: assumes (correctly) that ti_ctlsize is large enough
  91          * to hold sizeof (struct T_bind_req/ack)
  92          */
  93         if (_t_acquire_ctlbuf(tiptr, &ctlbuf, &didalloc) < 0) {
  94                 sv_errno = errno;
  95                 sig_mutex_unlock(&tiptr->ti_lock);
  96                 (void) thr_sigsetmask(SIG_SETMASK, &mask, NULL);
  97                 errno = sv_errno;
  98                 return (-1);
  99         }
 100
 101         /* LINTED pointer cast */
 102         bind_reqp = (struct T_bind_req *)ctlbuf.buf;
 103         size = (int)sizeof (struct T_bind_req);
 104
 105         use_xpg41tpi = (_T_IS_XTI(api_semantics)) &&
 106                 ((tiptr->ti_prov_flag & XPG4_1) != 0);
 107         if (use_xpg41tpi)
 108                 /* XTI call and provider knows the XTI inspired TPI */
 109                 bind_reqp->PRIM_type = T_BIND_REQ;
 110         else
 111                 /* TLI caller old TPI provider */
 112                 bind_reqp->PRIM_type = O_T_BIND_REQ;
 113
 114         bind_reqp->ADDR_length = (req == NULL? 0: req->addr.len);
 115         bind_reqp->ADDR_offset = 0;
 116         bind_reqp->CONIND_number = (req == NULL? 0: req->qlen);
 117
 118
 119         if (bind_reqp->ADDR_length) {
 120                 if (_t_aligned_copy(&ctlbuf, (int)bind_reqp->ADDR_length, size,
 121                     req->addr.buf, &bind_reqp->ADDR_offset) < 0) {
 122                         /*
 123                          * Aligned copy will overflow buffer allocated based
 124                          * on transport maximum address length.
 125                          * return error.
 126                          */
 127                         t_errno = TBADADDR;
 128                         goto err_out;
 129                 }
 130                 size = bind_reqp->ADDR_offset + bind_reqp->ADDR_length;
 131         }
 132
 133         if (_t_do_ioctl(fd, ctlbuf.buf, size, TI_BIND, &retlen) < 0) {
 134                 goto err_out;
 135         }
 136
 137         if (retlen < (int)sizeof (struct T_bind_ack)) {
 138                 t_errno = TSYSERR;
 139                 errno = EIO;
 140                 goto err_out;
 141         }
 142
 143         /* LINTED pointer cast */
 144         bind_ackp = (struct T_bind_ack *)ctlbuf.buf;
 145
 146         if ((req != NULL) && req->addr.len != 0 &&
 147             (use_xpg41tpi == 0) && (_T_IS_XTI(api_semantics))) {
 148                 /*
 149                  * Best effort to do XTI on old TPI.
 150                  *
 151                  * Match address requested or unbind and fail with
 152                  * TADDRBUSY.
 153                  *
 154                  * XXX - Hack alert ! Should we do this at all ?
 155                  * Not "supported" as may not work if encoding of
 156                  * address is different in the returned address. This
 157                  * will also have trouble with TCP/UDP wildcard port
 158                  * requests
 159                  */
 160                 if ((req->addr.len != bind_ackp->ADDR_length) ||
 161                     (memcmp(req->addr.buf, ctlbuf.buf +
 162                     bind_ackp->ADDR_offset, req->addr.len) != 0)) {
 163                         (void) _tx_unbind_locked(fd, tiptr, &ctlbuf);
 164                         t_errno = TADDRBUSY;
 165                         goto err_out;
 166                 }
 167         }
 168
 169         tiptr->ti_ocnt = 0;
 170         tiptr->ti_flags &= ~TX_TQFULL_NOTIFIED;
 171
 172         _T_TX_NEXTSTATE(T_BIND, tiptr, "t_bind: invalid state event T_BIND");
 173
 174         if (ret != NULL) {
 175                 if (_T_IS_TLI(api_semantics) || ret->addr.maxlen > 0) {
 176                         if (TLEN_GT_NLEN(bind_reqp->ADDR_length,
 177                             ret->addr.maxlen)) {
 178                                 t_errno = TBUFOVFLW;
 179                                 goto err_out;
 180                         }
 181                         (void) memcpy(ret->addr.buf,
 182                             ctlbuf.buf + bind_ackp->ADDR_offset,
 183                             (size_t)bind_ackp->ADDR_length);
 184                         ret->addr.len = bind_ackp->ADDR_length;
 185                 }
 186                 ret->qlen = bind_ackp->CONIND_number;
 187         }
 188
 189         tiptr->ti_qlen = (uint_t)bind_ackp->CONIND_number;
 190
 191         if (didalloc)
 192                 free(ctlbuf.buf);
 193         else
 194                 tiptr->ti_ctlbuf = ctlbuf.buf;
 195         sig_mutex_unlock(&tiptr->ti_lock);
 196         (void) thr_sigsetmask(SIG_SETMASK, &mask, NULL);
 197         return (0);
 198         /* NOTREACHED */
 199 err_out:
 200         sv_errno = errno;
 201         if (didalloc)
 202                 free(ctlbuf.buf);
 203         else
 204                 tiptr->ti_ctlbuf = ctlbuf.buf;
 205         sig_mutex_unlock(&tiptr->ti_lock);
 206         (void) thr_sigsetmask(SIG_SETMASK, &mask, NULL);
 207         errno = sv_errno;
 208         return (-1);
 209 }