socksctpsubr.c revision 903a11ebdc8df157c4700150f41f1f262f4a8ae8
/*
* 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
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/sysmacros.h>
#include <sys/vfs_opreg.h>
#include <sys/socketvar.h>
#include <inet/sctp_itf.h>
#include "socksctp.h"
/*
* for description of the algorithm.
*/
{
continue;
ralloc = 0;
}
}
return (id);
}
return (-1);
}
/*
* Allocate or free ID, depending on whether incr is 1 or -1
*/
void
{
}
}
/*
* Increase size of the ss_assocs array to accommodate at least maxid.
* We keep the size of the form 2^n - 1 for benefit of sosctp_aid_get().
*/
int
{
continue;
}
return (-1);
}
return (0);
}
}
return (0);
}
/*
* Convert a id into a pointer to sctp_sockassoc structure.
* Increments refcnt.
*/
int
{
return (EINVAL);
}
return (EINVAL);
}
/*
* Disconnected connection, shouldn't be found anymore
*/
return (ESHUTDOWN);
}
return (0);
}
/*
* Can be called from upcall, or through system call.
*/
struct sctp_soassoc *
{
struct sctp_soassoc *ssa;
ssa->ssa_txqueued = 0;
ssa->ssa_rxqueued = 0;
}
return (ssa);
}
void
{
}
--ss->ss_assoccnt;
}
/*
* Pack the ancillary stuff taking care of alignment issues.
* sctp_input_add_ancillary() packs the information as:
* struct cmsghdr -> ancillary data + struct cmsghdr -> ancillary data + ...
* In the next version of SCTP, sctp_input_add_ancillary() should
* pack the information taking alignment into account, then we would
* not need this routine.
*/
void
{
int optlen = 0;
char *cend;
/* Figure out the length incl. alignment et. al. */
for (;;) {
break;
}
} else {
break;
}
}
/* Now allocate and copy */
if (isaligned) {
return;
}
for (;;) {
break;
}
} else {
break;
}
}
}
/*
* Find cmsghdr of specified type
*/
struct cmsghdr *
{
char *cend;
for (;;) {
break;
}
return (cmsg);
}
} else {
break;
}
}
return (NULL);
}
/*
* Wait until the socket is connected or there is an error.
* fmode should contain any nonblocking flags.
*/
int
{
int error = 0;
return (EINPROGRESS);
/*
* Return EINTR and let the application use
* nonblocking techniques for detecting when
* the connection has been established.
*/
return (EINTR);
}
}
return (error);
}
/*
* Another thread could have consumed so_error
* e.g. by calling read. - take from sowaitconnected()
*/
return (error);
}
return (0);
}
/*
* Wait until the association is connected or there is an error.
* fmode should contain any nonblocking flags.
*/
static int
{
int error = 0;
return (EINPROGRESS);
/*
* Return EINTR and let the application use
* nonblocking techniques for detecting when
* the connection has been established.
*/
return (EINTR);
}
}
return (error);
}
/*
* Another thread could have consumed so_error
* e.g. by calling read. - take from sowaitconnected()
*/
return (error);
}
return (0);
}
/*
* Called from connect(), sendmsg() when we need to create a new association.
*/
int
struct sctp_soassoc **ssap)
{
struct sctp_soassoc *ssa;
struct sockaddr_storage laddr;
int error;
/*
* System needs to pick local endpoint
*/
sizeof (laddr), _SOBIND_LOCK_HELD);
if (error) {
return (error);
}
}
/*
* Create a new association, and call connect on that.
*/
for (;;) {
if (id != -1) {
break;
}
/*
* Array not large enough; increase size.
*/
}
++ss->ss_assoccnt;
return (ENOMEM);
}
/*
* Can specify special init params
*/
if (error != 0)
goto ret_err;
}
goto ret_err;
/*
* Allow other threads to access the socket
*/
switch (error) {
case 0:
case EINPROGRESS:
case EALREADY:
case EINTR:
/* Non-fatal errors */
break;
default:
/*
* Fatal errors. It means that sctp_assoc_disconnected()
* must have been called. So we only need to do a
* SSA_REFRELE() here to release our hold done above.
*/
break;
}
return (error);
/*
* There should not be any upcall done by SCTP. So normally the
* ssa_refcnt should be 2. And we can call sosctp_assoc_free()
* directly. But since the ssa is inserted to the ss_soassocs
* array above, some thread can actually put a hold on it. In
* this special case, we "manually" decrease the ssa_refcnt by 2.
*/
else
return (error);
}
/*
* Inherit socket properties
*/
void
{
}
/*
* Branching association to it's own socket. Inherit properties from
* the parent, and move data from RX queue to TX.
*/
void
struct sctp_soassoc *ssa)
{
struct sctp_soassoc *tmp;
if (nss->ss_rxqueued > 0) {
} else {
}
}
}
}
void
{
}
void
{
}
void
{
}
void
{
if (error != 0)
}
/*
*/
int
{
int error;
if (pid != 0) {
/*
* Permissions check by sending signal 0.
* Note that when kill fails it does a
* set_errno causing the system call to fail.
*/
if (error != 0) {
return (error);
}
}
return (0);
}
/*
* Generate a SIGIO, for 'writable' events include siginfo structure,
* for read events just send the signal.
*/
static void
{
if (event & SCTPSIG_WRITE) {
}
if (event & SCTPSIG_READ) {
}
}
void
{
return;
}
/*
* XXX This unfortunately still generates
* a signal when a fd is closed but
* the proc is active.
*/
return;
}
} else {
/*
* Send to process group. Hold pidlock across
* calls to sosctp_sigproc().
*/
}
}
}