OpenSolaris_b135/uts/common/inet/proto_set.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/types.h>
#include <inet/common.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/sysmacros.h>
#include <sys/stropts.h>
#include <sys/strsubr.h>
#include <sys/tpicommon.h>
#include <sys/socket_proto.h>
#include <sys/policy.h>
#include <inet/optcom.h>
#include <inet/ipclassifier.h>
boolean_t
proto_set_rx_hiwat(queue_t *q, conn_t *connp, size_t size)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_RCVHIWAT;
sopp.sopp_rxhiwat = size;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
} else {
MBLKP mp;
struct stroptions *stropt;
if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
return (B_FALSE);
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof (*stropt);
stropt = (struct stroptions *)mp->b_rptr;
stropt->so_flags = SO_HIWAT;
stropt->so_hiwat = size;
putnext(q, mp);
}
return (B_TRUE);
}
boolean_t
proto_set_rx_lowat(queue_t *q, conn_t *connp, size_t size)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_RCVLOWAT;
sopp.sopp_rxlowat = size;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
} else {
MBLKP mp;
struct stroptions *stropt;
if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
return (B_FALSE);
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof (*stropt);
stropt = (struct stroptions *)mp->b_rptr;
stropt->so_flags = SO_LOWAT;
stropt->so_lowat = size;
putnext(q, mp);
}
return (B_TRUE);
}
/*
* Set maximum packet size. This is the maximum amount of data the protocol
* wants to be given at any time, Larger data needs to be broken in multiples
* of maximum packet size and given to the protocol one at a time.
*/
boolean_t
proto_set_maxpsz(queue_t *q, conn_t *connp, size_t size)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_MAXPSZ;
sopp.sopp_maxpsz = size;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
return (B_TRUE);
} else {
struct stdata *stp;
queue_t *wq;
stp = STREAM(q);
/*
* At this point change of a queue parameter is not allowed
* when a multiplexor is sitting on top.
*/
if (stp == NULL || stp->sd_flag & STPLEX)
return (B_FALSE);
claimstr(stp->sd_wrq);
wq = stp->sd_wrq->q_next;
ASSERT(wq != NULL);
(void) strqset(wq, QMAXPSZ, 0, size);
releasestr(stp->sd_wrq);
return (B_TRUE);
}
}
/* ARGSUSED */
boolean_t
proto_set_tx_maxblk(queue_t *q, conn_t *connp, ssize_t size)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_MAXBLK;
sopp.sopp_maxblk = size;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
} else {
MBLKP mp;
struct stroptions *stropt;
if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
return (B_FALSE);
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof (*stropt);
stropt = (struct stroptions *)mp->b_rptr;
stropt->so_flags = SO_MAXBLK;
stropt->so_maxblk = size;
putnext(q, mp);
}
return (B_TRUE);
}
boolean_t
proto_set_tx_copyopt(queue_t *q, conn_t *connp, int copyopt)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_ZCOPY;
sopp.sopp_zcopyflag = (ushort_t)copyopt;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
} else {
MBLKP mp;
struct stroptions *stropt;
if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
return (B_FALSE);
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof (*stropt);
stropt = (struct stroptions *)mp->b_rptr;
stropt->so_flags = SO_COPYOPT;
stropt->so_copyopt = (ushort_t)copyopt;
putnext(q, mp);
}
return (B_TRUE);
}
boolean_t
proto_set_tx_wroff(queue_t *q, conn_t *connp, size_t size)
{
if (connp != NULL && IPCL_IS_NONSTR(connp)) {
struct sock_proto_props sopp;
sopp.sopp_flags = SOCKOPT_WROFF;
sopp.sopp_wroff = size;
/* XXX workaround for CR6757374 */
if (connp->conn_upper_handle != NULL)
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
} else {
MBLKP mp;
struct stroptions *stropt;
if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
return (B_FALSE);
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof (*stropt);
stropt = (struct stroptions *)mp->b_rptr;
stropt->so_flags = SO_WROFF;
stropt->so_wroff = (ushort_t)size;
putnext(q, mp);
}
return (B_TRUE);
}
/*
* set OOBINLINE processing on the socket
*/
void
proto_set_rx_oob_opt(conn_t *connp, boolean_t onoff)
{
struct sock_proto_props sopp;
ASSERT(IPCL_IS_NONSTR(connp));
sopp.sopp_flags = SOCKOPT_OOBINLINE;
sopp.sopp_oobinline = onoff;
(*connp->conn_upcalls->su_set_proto_props)
(connp->conn_upper_handle, &sopp);
}
/*
* Translate a TLI(/XTI) error into a system error as best we can.
*/
static const int tli_errs[] = {
0, /* no error */
EADDRNOTAVAIL, /* TBADADDR */
ENOPROTOOPT, /* TBADOPT */
EACCES, /* TACCES */
EBADF, /* TBADF */
EADDRNOTAVAIL, /* TNOADDR */
EPROTO, /* TOUTSTATE */
ECONNABORTED, /* TBADSEQ */
0, /* TSYSERR - will never get */
EPROTO, /* TLOOK - should never be sent by transport */
EMSGSIZE, /* TBADDATA */
EMSGSIZE, /* TBUFOVFLW */
EPROTO, /* TFLOW */
EWOULDBLOCK, /* TNODATA */
EPROTO, /* TNODIS */
EPROTO, /* TNOUDERR */
EINVAL, /* TBADFLAG */
EPROTO, /* TNOREL */
EOPNOTSUPP, /* TNOTSUPPORT */
EPROTO, /* TSTATECHNG */
/* following represent error namespace expansion with XTI */
EPROTO, /* TNOSTRUCTYPE - never sent by transport */
EPROTO, /* TBADNAME - never sent by transport */
EPROTO, /* TBADQLEN - never sent by transport */
EADDRINUSE, /* TADDRBUSY */
EBADF, /* TINDOUT */
EBADF, /* TPROVMISMATCH */
EBADF, /* TRESQLEN */
EBADF, /* TRESADDR */
EPROTO, /* TQFULL - never sent by transport */
EPROTO, /* TPROTO */
};
int
proto_tlitosyserr(int terr)
{
ASSERT(terr != TSYSERR);
if (terr >= (sizeof (tli_errs) / sizeof (tli_errs[0])))
return (EPROTO);
else
return (tli_errs[terr]);
}
/*
* Verify that address is suitable for connect/sendmsg and is aligned properly
* Since this is a generic function we do not test for port being zero
* as some protocols like icmp do not require a port
*/
int
proto_verify_ip_addr(int family, const struct sockaddr *name, socklen_t namelen)
{
if (name == NULL || !OK_32PTR((char *)name))
return (EINVAL);
switch (family) {
case AF_INET:
if (name->sa_family != AF_INET) {
return (EAFNOSUPPORT);
}
if (namelen != (socklen_t)sizeof (struct sockaddr_in)) {
return (EINVAL);
}
break;
case AF_INET6: {
#ifdef DEBUG
struct sockaddr_in6 *sin6;
#endif /* DEBUG */
if (name->sa_family != AF_INET6) {
return (EAFNOSUPPORT);
}
if (namelen != (socklen_t)sizeof (struct sockaddr_in6)) {
return (EINVAL);
}
#ifdef DEBUG
/* Verify that apps don't forget to clear sin6_scope_id etc */
sin6 = (struct sockaddr_in6 *)name;
if (sin6->sin6_scope_id != 0 &&
!IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr)) {
zcmn_err(getzoneid(), CE_WARN,
"connect/send* with uninitialized sin6_scope_id "
"(%d) on socket. Pid = %d\n",
(int)sin6->sin6_scope_id, (int)curproc->p_pid);
}
#endif /* DEBUG */
break;
}
default:
return (EINVAL);
}
return (0);
}
/*
* Do a lookup of the options in the array.
* Rerurn NULL if there isn't a match.
*/
opdes_t *
proto_opt_lookup(t_uscalar_t level, t_uscalar_t name, opdes_t *opt_arr,
uint_t opt_arr_cnt)
{
opdes_t *optd;
for (optd = opt_arr; optd < &opt_arr[opt_arr_cnt];
optd++) {
if (level == (uint_t)optd->opdes_level &&
name == (uint_t)optd->opdes_name)
return (optd);
}
return (NULL);
}
/*
* Do a lookup of the options in the array and do permission and length checking
* Returns zero if there is no error (note: for non-tpi-providers not being able
* to find the option is not an error). TPI errors are returned as negative
* numbers and errnos as positive numbers.
* If max_len is set we update it based on the max length of the option.
*/
int
proto_opt_check(int level, int name, int len, t_uscalar_t *max_len,
opdes_t *opt_arr, uint_t opt_arr_cnt, boolean_t negotiate, boolean_t check,
cred_t *cr)
{
opdes_t *optd;
/* Find the option in the opt_arr. */
optd = proto_opt_lookup(level, name, opt_arr, opt_arr_cnt);
if (optd == NULL)
return (-TBADOPT);
/* Additional checks dependent on operation. */
if (negotiate) {
/* Cannot be true at the same time */
ASSERT(check == B_FALSE);
if (!OA_WRITE_OR_EXECUTE(optd, cr)) {
/* can't negotiate option */
if (!(OA_MATCHED_PRIV(optd, cr)) &&
OA_WX_ANYPRIV(optd)) {
/*
* not privileged but privilege
* will help negotiate option.
*/
return (-TACCES);
} else {
return (-TBADOPT);
}
}
/*
* Verify size for options
* Note: For retaining compatibility with historical
* behavior, variable lengths options will have their
* length verified in the setfn() processing.
* In order to be compatible with SunOS 4.X we return
* EINVAL errors for bad lengths.
*/
if (!(optd->opdes_props & OP_VARLEN)) {
/* fixed length - size must match */
if (len != optd->opdes_size) {
return (EINVAL);
}
}
} else {
if (check) {
if (!OA_RWX_ANYPRIV(optd))
/* any of "rwx" permission but not none */
return (-TBADOPT);
}
/*
* XXX Since T_CURRENT was not there in TLI and the
* official TLI inspired TPI standard, getsockopt()
* API uses T_CHECK (for T_CURRENT semantics)
* Thus T_CHECK includes the T_CURRENT semantics due to that
* historical use.
*/
if (!OA_READ_PERMISSION(optd, cr)) {
/* can't read option value */
if (!(OA_MATCHED_PRIV(optd, cr)) &&
OA_R_ANYPRIV(optd)) {
/*
* not privileged but privilege
* will help in reading option value.
*/
return (-TACCES);
} else {
return (-TBADOPT);
}
}
}
if (max_len != NULL)
*max_len = optd->opdes_size;
/* We liked it. Keep going. */
return (0);
}