/*
* 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.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
/*
* TLI-like function to send datagrams over a specified
* transport endpoint.
*
* Returns:
* 0 on success or positive error code.
*/
#include <sys/param.h>
#include <sys/types.h>
#include <sys/user.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/vnode.h>
#include <sys/ioctl.h>
#include <sys/stropts.h>
#include <sys/tihdr.h>
#include <sys/timod.h>
#include <sys/tiuser.h>
#include <sys/t_kuser.h>
#include <sys/debug.h>
int
t_ksndudata(TIUSER *tiptr, struct t_kunitdata *unitdata, frtn_t *frtn)
{
int msgsz;
file_t *fp;
mblk_t *bp;
mblk_t *dbp;
struct T_unitdata_req *udreq;
int error;
int flag;
error = 0;
fp = tiptr->fp;
msgsz = unitdata->udata.len;
/*
* See if Class 0 is required
*/
if (frtn != NULL) {
ASSERT(unitdata->udata.udata_mp == NULL);
ASSERT(unitdata->udata.buf != NULL);
/*
* user has supplied their own buffer, all we have to
* do is allocate a class 0 streams buffer and set it
* up.
*/
if ((dbp = (mblk_t *)esballoc((uchar_t *)unitdata->udata.buf,
(size_t)msgsz, BPRI_LO, frtn)) == NULL)
return (ENOSR);
dbp->b_datap->db_type = M_DATA;
KTLILOG(2, "t_ksndudata: bp %x, ", dbp);
KTLILOG(2, "len %d, ", msgsz);
KTLILOG(2, "free func %x\n", frtn->free_func);
} else if (unitdata->udata.buf) {
ASSERT(unitdata->udata.udata_mp == NULL);
while (!(dbp = allocb(msgsz, BPRI_LO)))
if (strwaitbuf((size_t)msgsz, BPRI_LO))
return (ENOSR);
bcopy(unitdata->udata.buf, dbp->b_wptr, unitdata->udata.len);
dbp->b_datap->db_type = M_DATA;
} else if (unitdata->udata.udata_mp) {
ASSERT(unitdata->udata.buf == NULL);
/*
* user has done it all
*/
dbp = unitdata->udata.udata_mp;
goto gotdp;
} else {
/*
* zero length message.
*/
dbp = NULL;
}
if (dbp)
dbp->b_wptr += msgsz; /* on behalf of the user */
/*
* Okay, put the control part in
*/
gotdp:
msgsz = (int)TUNITDATAREQSZ;
/*
* Usually sendto()s are performed with the credential of the caller;
* in this particular case we specifically use the credential of
* the opener as this call is typically done in the context of a user
* process but on behalf of the kernel, e.g., a client connection
* to a server which is later shared by different users.
* At open time, we make sure to set fp->f_cred to kcred if such is
* the case.
*
* Note: if the receiver uses SCM_UCRED/getpeerucred the pid will
* appear as -1.
*/
while (!(bp = allocb_cred(msgsz + unitdata->addr.len +
unitdata->opt.len, fp->f_cred, NOPID))) {
if (strwaitbuf(msgsz + unitdata->addr.len + unitdata->opt.len,
BPRI_LO)) {
if (dbp && (dbp != unitdata->udata.udata_mp))
freeb(dbp);
return (ENOSR);
}
}
/* LINTED pointer alignment */
udreq = (struct T_unitdata_req *)bp->b_wptr;
udreq->PRIM_type = T_UNITDATA_REQ;
udreq->DEST_length = unitdata->addr.len;
if (unitdata->addr.len) {
bcopy(unitdata->addr.buf, bp->b_wptr + msgsz,
unitdata->addr.len);
udreq->DEST_offset = (t_scalar_t)msgsz;
msgsz += unitdata->addr.len;
} else
udreq->DEST_offset = 0;
udreq->OPT_length = unitdata->opt.len;
if (unitdata->opt.len) {
bcopy(unitdata->opt.buf, bp->b_wptr + msgsz, unitdata->opt.len);
udreq->OPT_offset = (t_scalar_t)msgsz;
msgsz += unitdata->opt.len;
} else
udreq->OPT_offset = 0;
bp->b_datap->db_type = M_PROTO;
bp->b_wptr += msgsz;
/*
* link the two.
*/
linkb(bp, dbp);
/*
* Put it to the transport provider.
* tli_send() always consumes the message.
*/
flag = fp->f_flag;
error = tli_send(tiptr, bp, flag);
unitdata->udata.udata_mp = NULL;
return (error);
}