static void
bootparamprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
bp_whoami_arg bootparamproc_whoami_1_arg;
bp_getfile_arg bootparamproc_getfile_1_arg;
} argument;
char *result;
bool_t (*xdr_argument)(), (*xdr_result)();
char *(*local)();
_rpcsvcdirty = 1;
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply(transp, xdr_void, (char *)NULL);
_rpcsvcdirty = 0;
return;
case BOOTPARAMPROC_WHOAMI:
xdr_argument = xdr_bp_whoami_arg;
xdr_result = xdr_bp_whoami_res;
local = (char *(*)()) bootparamproc_whoami_1;
break;
case BOOTPARAMPROC_GETFILE:
xdr_argument = xdr_bp_getfile_arg;
xdr_result = xdr_bp_getfile_res;
local = (char *(*)()) bootparamproc_getfile_1;
break;
default:
svcerr_noproc(transp);
_rpcsvcdirty = 0;
return;
}
(void) memset((char *)&argument, 0, sizeof (argument));
if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) {
svcerr_decode(transp);
_rpcsvcdirty = 0;
return;
}
result = (*local)(&argument, rqstp);
if (result != NULL && !svc_sendreply(transp, xdr_result, result)) {
svcerr_systemerr(transp);
}
if (!svc_freeargs(transp, xdr_argument, (caddr_t)&argument)) {
msgout("unable to free arguments");
exit(EXIT_FAILURE);
}
_rpcsvcdirty = 0;
}
void
wallprog_1(struct svc_req *rqstp, SVCXPRT *transp)
{
union {
char *wallproc_wall_1_arg;
} argument;
char *result;
bool_t (*xdr_argument)(), (*xdr_result)();
char *(*local)();
switch (rqstp->rq_proc) {
case NULLPROC:
(void)svc_sendreply(transp, (xdrproc_t)xdr_void, NULL);
goto leave;
case WALLPROC_WALL:
xdr_argument = xdr_wrapstring;
xdr_result = xdr_void;
local = (char *(*)()) wallproc_wall_1_svc;
break;
default:
svcerr_noproc(transp);
goto leave;
}
bzero((char *)&argument, sizeof(argument));
if (!svc_getargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument)) {
svcerr_decode(transp);
goto leave;
}
result = (*local)(&argument, rqstp);
if (result != NULL &&
!svc_sendreply(transp, (xdrproc_t)xdr_result, result)) {
svcerr_systemerr(transp);
}
if (!svc_freeargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument)) {
syslog(LOG_ERR, "unable to free arguments");
exit(1);
}
leave:
if (from_inetd)
exit(0);
}
void
rstat_service(struct svc_req *rqstp, SVCXPRT *transp)
{
union {
int fill;
} argument;
char *result;
bool_t (*xdr_argument)(), (*xdr_result)();
char *(*local)();
switch (rqstp->rq_proc) {
case NULLPROC:
(void)svc_sendreply(transp, (xdrproc_t)xdr_void, NULL);
goto leave;
case RSTATPROC_STATS:
xdr_argument = xdr_void;
xdr_result = xdr_statstime;
switch (rqstp->rq_vers) {
case RSTATVERS_ORIG:
local = (char *(*)()) rstatproc_stats_1_svc;
break;
case RSTATVERS_SWTCH:
local = (char *(*)()) rstatproc_stats_2_svc;
break;
case RSTATVERS_TIME:
local = (char *(*)()) rstatproc_stats_3_svc;
break;
default:
svcerr_progvers(transp, RSTATVERS_ORIG, RSTATVERS_TIME);
goto leave;
/*NOTREACHED*/
}
break;
case RSTATPROC_HAVEDISK:
xdr_argument = xdr_void;
xdr_result = xdr_u_int;
switch (rqstp->rq_vers) {
case RSTATVERS_ORIG:
local = (char *(*)()) rstatproc_havedisk_1_svc;
break;
case RSTATVERS_SWTCH:
local = (char *(*)()) rstatproc_havedisk_2_svc;
break;
case RSTATVERS_TIME:
local = (char *(*)()) rstatproc_havedisk_3_svc;
break;
default:
svcerr_progvers(transp, RSTATVERS_ORIG, RSTATVERS_TIME);
goto leave;
/*NOTREACHED*/
}
break;
default:
svcerr_noproc(transp);
goto leave;
}
bzero((char *)&argument, sizeof(argument));
if (!svc_getargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument)) {
svcerr_decode(transp);
goto leave;
}
result = (*local)(&argument, rqstp);
if (result != NULL &&
!svc_sendreply(transp, (xdrproc_t)xdr_result, result)) {
svcerr_systemerr(transp);
}
if (!svc_freeargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument))
errx(1, "unable to free arguments");
leave:
if (from_inetd)
exit(0);
}
/* autofs program dispatcher */
static void
autofs_program_1(struct svc_req *rqstp, SVCXPRT *transp)
{
union {
mntrequest autofs_mount_1_arg;
umntrequest autofs_umount_1_arg;
} argument;
union {
mntres mount_res;
umntres umount_res;
} result;
int ret;
bool_t (*xdr_argument)();
bool_t (*xdr_result)();
int (*local)();
current_transp = transp;
switch (rqstp->rq_proc) {
case AUTOFS_NULL:
svc_sendreply(transp,
(XDRPROC_T_TYPE) xdr_void,
(SVC_IN_ARG_TYPE) NULL);
return;
case AUTOFS_MOUNT:
xdr_argument = xdr_mntrequest;
xdr_result = xdr_mntres;
local = autofs_mount_1_req;
break;
case AUTOFS_UNMOUNT:
xdr_argument = xdr_umntrequest;
xdr_result = xdr_umntres;
local = autofs_unmount_1_req;
break;
default:
svcerr_noproc(transp);
return;
}
memset((char *) &argument, 0, sizeof(argument));
if (!svc_getargs(transp,
(XDRPROC_T_TYPE) xdr_argument,
(SVC_IN_ARG_TYPE) &argument)) {
plog(XLOG_ERROR,
"AUTOFS xdr decode failed for %d %d %d",
(int) rqstp->rq_prog, (int) rqstp->rq_vers, (int) rqstp->rq_proc);
svcerr_decode(transp);
return;
}
memset((char *)&result, 0, sizeof(result));
ret = (*local) (&argument, &result, rqstp, transp);
current_transp = NULL;
/* send reply only if the RPC method returned 0 */
if (!ret) {
if (!svc_sendreply(transp,
(XDRPROC_T_TYPE) xdr_result,
(SVC_IN_ARG_TYPE) &result)) {
svcerr_systemerr(transp);
}
}
if (!svc_freeargs(transp,
(XDRPROC_T_TYPE) xdr_argument,
(SVC_IN_ARG_TYPE) &argument)) {
plog(XLOG_FATAL, "unable to free rpc arguments in autofs_program_1");
}
}
void
rusers_service(struct svc_req *rqstp, SVCXPRT *transp)
{
union {
int fill;
} argument;
char *result;
bool_t (*xdr_argument)(), (*xdr_result)();
char *(*local)();
switch (rqstp->rq_proc) {
case NULLPROC:
(void)svc_sendreply(transp, (xdrproc_t)xdr_void, NULL);
goto leave;
case RUSERSPROC_NUM:
xdr_argument = xdr_void;
xdr_result = xdr_int;
local = (char *(*)()) rusers_num;
break;
case RUSERSPROC_NAMES:
xdr_argument = xdr_void;
xdr_result = xdr_utmpidlearr;
switch (rqstp->rq_vers) {
case RUSERSVERS_ORIG:
local = (char *(*)()) rusersproc_names_1_svc;
break;
case RUSERSVERS_IDLE:
local = (char *(*)()) rusersproc_names_2_svc;
break;
default:
svcerr_progvers(transp, RUSERSVERS_ORIG, RUSERSVERS_IDLE);
goto leave;
/*NOTREACHED*/
}
break;
case RUSERSPROC_ALLNAMES:
xdr_argument = xdr_void;
xdr_result = xdr_utmpidlearr;
switch (rqstp->rq_vers) {
case RUSERSVERS_ORIG:
local = (char *(*)()) rusersproc_allnames_1_svc;
break;
case RUSERSVERS_IDLE:
local = (char *(*)()) rusersproc_allnames_2_svc;
break;
default:
svcerr_progvers(transp, RUSERSVERS_ORIG, RUSERSVERS_IDLE);
goto leave;
/*NOTREACHED*/
}
break;
default:
svcerr_noproc(transp);
goto leave;
}
bzero((char *)&argument, sizeof(argument));
if (!svc_getargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument)) {
svcerr_decode(transp);
goto leave;
}
result = (*local)(&argument, rqstp);
if (result != NULL &&
!svc_sendreply(transp, (xdrproc_t)xdr_result, result)) {
svcerr_systemerr(transp);
}
if (!svc_freeargs(transp, (xdrproc_t)xdr_argument, (caddr_t)&argument)) {
syslog(LOG_ERR, "unable to free arguments");
exit(1);
}
leave:
if (from_inetd)
exit(0);
}
/*
* XXX - This is a shorter version of vattr_to_fattr4 which only takes care
* of setattr args - size, mode, uid/gid, times. Eventually we should generalize
* by using nfs4_ntov_map and the same functions used by the server.
* Here we just hardcoded the setattr attributes. Note that the order is
* important - it should follow the order of the bits in the mask.
*/
int
vattr_to_fattr4(vattr_t *vap, vsecattr_t *vsap, fattr4 *fattrp, int flags,
enum nfs_opnum4 op, bitmap4 supp)
{
int i, j;
union nfs4_attr_u *na = NULL;
int attrcnt;
int uid_attr = -1;
int gid_attr = -1;
int acl_attr = -1;
XDR xdr;
ulong_t xdr_size;
char *xdr_attrs;
int error = 0;
uint8_t amap[NFS4_MAXNUM_ATTRS];
uint_t va_mask = vap->va_mask;
bool_t (*attrfunc)();
#ifndef lint
/*
* Make sure that maximum attribute number can be expressed as an
* 8 bit quantity.
*/
ASSERT(NFS4_MAXNUM_ATTRS <= (UINT8_MAX + 1));
#endif
fattrp->attrmask = 0;
fattrp->attrlist4_len = 0;
fattrp->attrlist4 = NULL;
na = kmem_zalloc(sizeof (union nfs4_attr_u) * nfs4_ntov_map_size,
KM_SLEEP);
if (op == OP_SETATTR || op == OP_CREATE || op == OP_OPEN) {
/*
* Note we need to set the attrmask for set operations.
* In particular mtime and atime will be set to the
* servers time.
*/
nfs4_vmask_to_nmask_set(va_mask, &fattrp->attrmask);
if (vsap != NULL)
fattrp->attrmask |= FATTR4_ACL_MASK;
attrfunc = nfs4_set_fattr4_attr;
} else { /* verify/nverify */
/*
* Verfy/nverify use the "normal vmask_to_nmask
* this routine knows how to handle all vmask bits
*/
nfs4_vmask_to_nmask(va_mask, &fattrp->attrmask);
/*
* XXX verify/nverify only works for a subset of attrs that
* directly map to vattr_t attrs. So, verify/nverify is
* broken for servers that only support mandatory attrs.
* Mask out change attr for now and fix verify op to
* work with mandonly servers later. nfs4_vmask_to_nmask
* sets change whenever it sees request for ctime/mtime,
* so we must turn off change because nfs4_ver_fattr4_attr
* will not generate args for change. This is a bug
* that will be fixed later.
* XXX
*/
fattrp->attrmask &= ~FATTR4_CHANGE_MASK;
attrfunc = nfs4_ver_fattr4_attr;
}
/* Mask out any rec attrs unsupported by server */
fattrp->attrmask &= supp;
attrcnt = 0;
xdr_size = 0;
for (i = 0; i < nfs4_ntov_map_size; i++) {
/*
* In the case of FATTR4_ACL_MASK, the vbit will be 0 (zero)
* so we must also check if the fbit is FATTR4_ACL_MASK before
* skipping over this attribute.
*/
if (!(nfs4_ntov_map[i].vbit & vap->va_mask)) {
if (nfs4_ntov_map[i].fbit != FATTR4_ACL_MASK)
continue;
if (vsap == NULL)
continue;
}
if (attrfunc == nfs4_set_fattr4_attr) {
if (!(*attrfunc)(vap, vsap, &nfs4_ntov_map[i],
&na[attrcnt], flags, &error))
continue;
} else if (attrfunc == nfs4_ver_fattr4_attr) {
if (!(*attrfunc)(vap, &nfs4_ntov_map[i], &na[attrcnt],
flags, &error))
continue;
}
if (error)
goto done; /* Exit! */
/*
* Calculate XDR size
*/
if (nfs4_ntov_map[i].xdr_size != 0) {
/*
* If we are setting attributes (attrfunc is
* nfs4_set_fattr4_attr) and are setting the
* mtime or atime, adjust the xdr size down by
* 3 words, since we are using the server's
* time as the current time. Exception: if
* ATTR_UTIME is set, the client sends the
* time, so leave the xdr size alone.
*/
xdr_size += nfs4_ntov_map[i].xdr_size;
if ((nfs4_ntov_map[i].nval == FATTR4_TIME_ACCESS_SET ||
nfs4_ntov_map[i].nval == FATTR4_TIME_MODIFY_SET) &&
attrfunc == nfs4_set_fattr4_attr &&
!(flags & ATTR_UTIME)) {
xdr_size -= 3 * BYTES_PER_XDR_UNIT;
}
} else {
/*
* The only zero xdr_sizes we should see
* are AT_UID, AT_GID and FATTR4_ACL_MASK
*/
ASSERT(nfs4_ntov_map[i].vbit == AT_UID ||
nfs4_ntov_map[i].vbit == AT_GID ||
nfs4_ntov_map[i].fbit == FATTR4_ACL_MASK);
if (nfs4_ntov_map[i].vbit == AT_UID) {
uid_attr = attrcnt;
xdr_size += BYTES_PER_XDR_UNIT; /* length */
xdr_size +=
RNDUP(na[attrcnt].owner.utf8string_len);
} else if (nfs4_ntov_map[i].vbit == AT_GID) {
gid_attr = attrcnt;
xdr_size += BYTES_PER_XDR_UNIT; /* length */
xdr_size +=
RNDUP(
na[attrcnt].owner_group.utf8string_len);
} else if (nfs4_ntov_map[i].fbit == FATTR4_ACL_MASK) {
nfsace4 *tmpacl = (nfsace4 *)vsap->vsa_aclentp;
acl_attr = attrcnt;
/* fattr4_acl_len */
xdr_size += BYTES_PER_XDR_UNIT;
/* fattr4_acl_val */
xdr_size += RNDUP((vsap->vsa_aclcnt *
(sizeof (acetype4) + sizeof (aceflag4)
+ sizeof (acemask4))));
for (j = 0; j < vsap->vsa_aclcnt; j++) {
/* who - utf8string_len */
xdr_size += BYTES_PER_XDR_UNIT;
/* who - utf8string_val */
xdr_size +=
RNDUP(tmpacl[j].who.utf8string_len);
}
}
}
/*
* This attr is going otw
*/
amap[attrcnt] = (uint8_t)nfs4_ntov_map[i].nval;
attrcnt++;
/*
* Clear this bit from test mask so we stop
* as soon as all requested attrs are done.
*/
va_mask &= ~nfs4_ntov_map[i].vbit;
if (va_mask == 0 &&
(vsap == NULL || (vsap != NULL && acl_attr != -1)))
break;
}
if (attrcnt == 0) {
goto done;
}
fattrp->attrlist4 = xdr_attrs = kmem_alloc(xdr_size, KM_SLEEP);
fattrp->attrlist4_len = xdr_size;
xdrmem_create(&xdr, xdr_attrs, xdr_size, XDR_ENCODE);
for (i = 0; i < attrcnt; i++) {
if ((*nfs4_ntov_map[amap[i]].xfunc)(&xdr, &na[i]) == FALSE) {
cmn_err(CE_WARN, "vattr_to_fattr4: xdr encode of "
"attribute failed\n");
error = EINVAL;
break;
}
}
done:
/*
* Free any malloc'd attrs, can only be uid or gid
*/
if (uid_attr != -1 && na[uid_attr].owner.utf8string_val != NULL) {
kmem_free(na[uid_attr].owner.utf8string_val,
na[uid_attr].owner.utf8string_len);
}
if (gid_attr != -1 && na[gid_attr].owner_group.utf8string_val != NULL) {
kmem_free(na[gid_attr].owner_group.utf8string_val,
na[gid_attr].owner_group.utf8string_len);
}
/* xdrmem_destroy(&xdrs); */ /* NO-OP */
kmem_free(na, sizeof (union nfs4_attr_u) * nfs4_ntov_map_size);
if (error)
nfs4_fattr4_free(fattrp);
return (error);
}
void
krb5_iprop_prog_1(struct svc_req *rqstp,
register SVCXPRT *transp)
{
union {
kdb_last_t iprop_get_updates_1_arg;
} argument;
char *result;
bool_t (*_xdr_argument)(), (*_xdr_result)();
char *(*local)(/* union XXX *, struct svc_req * */);
char *whoami = "krb5_iprop_prog_1";
if (!check_iprop_rpcsec_auth(rqstp)) {
krb5_klog_syslog(LOG_ERR,
"authentication attempt failed: %s, RPC authentication flavor %d",
inet_ntoa(rqstp->rq_xprt->xp_raddr.sin_addr),
rqstp->rq_cred.oa_flavor);
svcerr_weakauth(transp);
return;
}
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply(transp, xdr_void,
(char *)NULL);
return;
case IPROP_GET_UPDATES:
_xdr_argument = xdr_kdb_last_t;
_xdr_result = xdr_kdb_incr_result_t;
local = (char *(*)()) iprop_get_updates_1_svc;
break;
case IPROP_FULL_RESYNC:
_xdr_argument = xdr_void;
_xdr_result = xdr_kdb_fullresync_result_t;
local = (char *(*)()) iprop_full_resync_1_svc;
break;
default:
krb5_klog_syslog(LOG_ERR,
_("RPC unknown request: %d (%s)"),
rqstp->rq_proc, whoami);
svcerr_noproc(transp);
return;
}
(void) memset((char *)&argument, 0, sizeof (argument));
if (!svc_getargs(transp, _xdr_argument, (caddr_t)&argument)) {
krb5_klog_syslog(LOG_ERR,
_("RPC svc_getargs failed (%s)"),
whoami);
svcerr_decode(transp);
return;
}
result = (*local)(&argument, rqstp);
if (_xdr_result && result != NULL &&
!svc_sendreply(transp, _xdr_result, result)) {
krb5_klog_syslog(LOG_ERR,
_("RPC svc_sendreply failed (%s)"),
whoami);
svcerr_systemerr(transp);
}
if (!svc_freeargs(transp, _xdr_argument, (caddr_t)&argument)) {
krb5_klog_syslog(LOG_ERR,
_("RPC svc_freeargs failed (%s)"),
whoami);
exit(1);
}
if (rqstp->rq_proc == IPROP_GET_UPDATES) {
/* LINTED */
kdb_incr_result_t *r = (kdb_incr_result_t *)result;
if (r->ret == UPDATE_OK) {
ulog_free_entries(r->updates.kdb_ulog_t_val,
r->updates.kdb_ulog_t_len);
r->updates.kdb_ulog_t_val = NULL;
r->updates.kdb_ulog_t_len = 0;
}
}
}
bool atomic_base<Base>::rev_sparse_hes(
const vector<Base>& x ,
const local::pod_vector<size_t>& x_index ,
const local::pod_vector<size_t>& y_index ,
const InternalSparsity& for_jac_sparsity ,
bool* rev_jac_flag ,
InternalSparsity& rev_hes_sparsity )
{ CPPAD_ASSERT_UNKNOWN( for_jac_sparsity.end() == rev_hes_sparsity.end() );
size_t q = rev_hes_sparsity.end();
size_t n = x_index.size();
size_t m = y_index.size();
bool ok = false;
size_t thread = thread_alloc::thread_num();
allocate_work(thread);
bool zero_empty = true;
bool input_empty = false;
bool transpose = false;
//
// vx
vector<bool> vx(n);
for(size_t j = 0; j < n; j++)
vx[j] = x_index[j] != 0;
//
// note that s and t are vectors so transpose does not matter for bool case
vector<bool> bool_s( work_[thread]->bool_s );
vector<bool> bool_t( work_[thread]->bool_t );
//
bool_s.resize(m);
bool_t.resize(n);
//
for(size_t i = 0; i < m; i++)
{ if( y_index[i] > 0 )
bool_s[i] = rev_jac_flag[ y_index[i] ];
}
//
std::string msg = ": atomic_base.rev_sparse_hes: returned false";
if( sparsity_ == pack_sparsity_enum )
{ vectorBool& pack_r( work_[thread]->pack_r );
vectorBool& pack_u( work_[thread]->pack_u );
vectorBool& pack_v( work_[thread]->pack_h );
//
pack_v.resize(n * q);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, pack_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, pack_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = pack_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, pack_v
);
}
else if( sparsity_ == bool_sparsity_enum )
{ vector<bool>& bool_r( work_[thread]->bool_r );
vector<bool>& bool_u( work_[thread]->bool_u );
vector<bool>& bool_v( work_[thread]->bool_h );
//
bool_v.resize(n * q);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, bool_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, bool_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = bool_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, bool_v
);
}
else
{ CPPAD_ASSERT_UNKNOWN( sparsity_ == set_sparsity_enum );
vector< std::set<size_t> >& set_r( work_[thread]->set_r );
vector< std::set<size_t> >& set_u( work_[thread]->set_u );
vector< std::set<size_t> >& set_v( work_[thread]->set_h );
//
set_v.resize(n);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, set_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, set_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = set_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, set_v
);
}
for(size_t j = 0; j < n; j++)
{ if( x_index[j] > 0 )
rev_jac_flag[ x_index[j] ] |= bool_t[j];
}
return ok;
}