nss_status_t
_nscd_doorcall(int callnum)
{
size_t buflen;
nss_pheader_t *phdr;
void *dptr;
size_t ndata;
size_t adata;
int ret;
char *me = "_nscd_doorcall";
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "processing door call %d ...\n", callnum);
/* allocate door buffer from the stack */
NSCD_ALLOC_DOORBUF(callnum, 0, dptr, buflen);
ndata = buflen;
adata = buflen;
ret = _nsc_trydoorcall(&dptr, &ndata, &adata);
if (ret != NSS_SUCCESS) {
phdr = (nss_pheader_t *)dptr;
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "door call (%d) failed (status = %d, error = %s)\n",
callnum, ret, strerror(NSCD_GET_ERRNO(phdr)));
}
return (ret);
}
nss_status_t
_nscd_doorcall_data(int callnum, void *indata, int indlen,
void *outdata, int outdlen, nss_pheader_t *phdr)
{
void *uptr;
size_t buflen;
void *dptr;
void *datap;
size_t ndata;
size_t adata;
nss_pheader_t *phdr_d;
int ret;
char *me = "_nscd_doorcall_data";
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "processing door call %d ...\n", callnum);
/* allocate door buffer from the stack */
NSCD_ALLOC_DOORBUF(callnum, indlen, uptr, buflen);
dptr = uptr;
ndata = buflen;
adata = buflen;
datap = NSCD_N2N_DOOR_DATA(void, dptr);
if (indata != NULL)
(void) memmove(datap, indata, indlen);
ret = _nsc_trydoorcall(&dptr, &ndata, &adata);
phdr_d = (nss_pheader_t *)dptr;
if (ret != NSS_SUCCESS) {
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "door call (%d) failed (status = %d, error = %s)\n",
callnum, ret, strerror(NSCD_GET_ERRNO(phdr_d)));
} else {
if (phdr != NULL) {
NSCD_COPY_STATUS(phdr, phdr_d);
}
ret = copy_output(outdata, outdlen, phdr_d, phdr);
}
/* if new buffer allocated for this door call, free it */
if (dptr != uptr)
(void) munmap(dptr, ndata);
return (ret);
}
nss_status_t
_nscd_doorcall_sendfd(int fd, int callnum, void *indata, int indlen,
nss_pheader_t *phdr)
{
void *uptr;
void *dptr;
void *datap;
size_t ndata;
size_t adata;
size_t buflen;
nss_pheader_t *phdr_d;
door_desc_t desc;
char *me = "_nscd_doorcall_sendfd";
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "processing door call %d (fd = %d)...\n", callnum, fd);
/* allocate door buffer from the stack */
NSCD_ALLOC_DOORBUF(callnum, indlen, uptr, buflen);
dptr = uptr;
ndata = buflen;
adata = buflen;
datap = NSCD_N2N_DOOR_DATA(void, dptr);
if (indata != NULL)
(void) memmove(datap, indata, indlen);
desc.d_attributes = DOOR_DESCRIPTOR;
desc.d_data.d_desc.d_descriptor = fd;
send_doorfd(&dptr, &ndata, &adata, &desc);
phdr_d = (nss_pheader_t *)dptr;
if (NSCD_STATUS_IS_NOT_OK(phdr_d)) {
if (phdr != NULL)
*phdr = *phdr_d;
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "door call (%d) failed (status = %d, error = %s)\n",
callnum, NSCD_GET_STATUS(phdr_d),
strerror(NSCD_GET_ERRNO(phdr_d)));
}
return (NSCD_GET_STATUS(phdr_d));
}
/*ARGSUSED*/
static void
switcher(void *cookie, char *argp, size_t arg_size,
door_desc_t *dp, uint_t n_desc)
{
int iam;
pid_t ent_pid = -1;
nss_pheader_t *phdr = (nss_pheader_t *)((void *)argp);
void *uptr;
int len;
size_t buflen;
int callnum;
char *me = "switcher";
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "switcher ...\n");
if (argp == DOOR_UNREF_DATA) {
(void) printf("Door Slam... exiting\n");
exit(0);
}
if (argp == NULL) { /* empty door call */
(void) door_return(NULL, 0, 0, 0); /* return the favor */
}
/*
* need to restart if main nscd and config file(s) changed
*/
if (_whoami == NSCD_MAIN)
_nscd_restart_if_cfgfile_changed();
if ((phdr->nsc_callnumber & NSCDV2CATMASK) == NSCD_CALLCAT_APP) {
/* make sure the packed buffer header is good */
if (validate_pheader(argp, arg_size,
phdr->nsc_callnumber) == -1)
(void) door_return(argp, arg_size, NULL, 0);
switch (phdr->nsc_callnumber) {
case NSCD_SEARCH:
/* if a fallback to main nscd, skip per-user setup */
if (phdr->p_status != NSS_ALTRETRY)
if_selfcred_return_per_user_door(argp, arg_size,
dp, _whoami);
lookup(argp, arg_size);
break;
case NSCD_SETENT:
_nscd_APP_check_cred(argp, &ent_pid, "NSCD_SETENT",
NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_ALERT);
if (NSCD_STATUS_IS_OK(phdr)) {
if_selfcred_return_per_user_door(argp, arg_size,
dp, _whoami);
nss_psetent(argp, arg_size, ent_pid);
}
break;
case NSCD_GETENT:
getent(argp, arg_size);
break;
case NSCD_ENDENT:
nss_pendent(argp, arg_size);
break;
case NSCD_PUT:
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_ERROR)
(me, "door call NSCD_PUT not supported yet\n");
NSCD_SET_STATUS(phdr, NSS_ERROR, ENOTSUP);
break;
case NSCD_GETHINTS:
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_ERROR)
(me, "door call NSCD_GETHINTS not supported yet\n");
NSCD_SET_STATUS(phdr, NSS_ERROR, ENOTSUP);
break;
default:
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_ERROR)
(me, "Unknown name service door call op %x\n",
phdr->nsc_callnumber);
NSCD_SET_STATUS(phdr, NSS_ERROR, EINVAL);
break;
}
(void) door_return(argp, arg_size, NULL, 0);
}
iam = NSCD_MAIN;
callnum = phdr->nsc_callnumber & ~NSCD_WHOAMI;
if (callnum == NSCD_IMHERE ||
callnum == NSCD_PULSE || callnum == NSCD_FORK)
iam = phdr->nsc_callnumber & NSCD_WHOAMI;
else
callnum = phdr->nsc_callnumber;
/* nscd -> nscd v2 calls */
/* make sure the buffer is good */
if (validate_N2Nbuf(argp, arg_size, callnum) == -1)
(void) door_return(argp, arg_size, NULL, 0);
switch (callnum) {
case NSCD_PING:
NSCD_SET_STATUS_SUCCESS(phdr);
break;
case NSCD_IMHERE:
_nscd_proc_iamhere(argp, dp, n_desc, iam);
break;
case NSCD_PULSE:
N2N_check_priv(argp, "NSCD_PULSE");
if (NSCD_STATUS_IS_OK(phdr))
_nscd_proc_pulse(argp, iam);
break;
case NSCD_FORK:
N2N_check_priv(argp, "NSCD_FORK");
if (NSCD_STATUS_IS_OK(phdr))
_nscd_proc_fork(argp, iam);
break;
case NSCD_KILL:
N2N_check_priv(argp, "NSCD_KILL");
if (NSCD_STATUS_IS_OK(phdr))
exit(0);
break;
case NSCD_REFRESH:
N2N_check_priv(argp, "NSCD_REFRESH");
if (NSCD_STATUS_IS_OK(phdr)) {
if (_nscd_refresh() != NSCD_SUCCESS)
exit(1);
NSCD_SET_STATUS_SUCCESS(phdr);
}
break;
case NSCD_GETPUADMIN:
if (_nscd_is_self_cred_on(0, NULL)) {
_nscd_peruser_getadmin(argp, sizeof (nscd_admin_t));
} else {
NSCD_SET_N2N_STATUS(phdr, NSS_NSCD_PRIV, 0,
NSCD_SELF_CRED_NOT_CONFIGURED);
}
break;
case NSCD_GETADMIN:
len = _nscd_door_getadmin((void *)argp);
if (len == 0)
break;
/* size of door buffer not big enough, allocate one */
NSCD_ALLOC_DOORBUF(NSCD_GETADMIN, len, uptr, buflen);
/* copy packed header */
*(nss_pheader_t *)uptr = *(nss_pheader_t *)((void *)argp);
/* set new buffer size */
((nss_pheader_t *)uptr)->pbufsiz = buflen;
/* try one more time */
(void) _nscd_door_getadmin((void *)uptr);
(void) door_return(uptr, buflen, NULL, 0);
break;
case NSCD_SETADMIN:
N2N_check_priv(argp, "NSCD_SETADMIN");
if (NSCD_STATUS_IS_OK(phdr))
_nscd_door_setadmin(argp);
break;
case NSCD_KILLSERVER:
N2N_check_priv(argp, "NSCD_KILLSERVER");
if (NSCD_STATUS_IS_OK(phdr)) {
/* also kill the forker nscd if one is running */
_nscd_kill_forker();
exit(0);
}
break;
default:
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_ERROR)
(me, "Unknown name service door call op %d\n",
phdr->nsc_callnumber);
NSCD_SET_STATUS(phdr, NSS_ERROR, EINVAL);
(void) door_return(argp, arg_size, NULL, 0);
break;
}
(void) door_return(argp, arg_size, NULL, 0);
}
nss_status_t
_nscd_doorcall_fd(int fd, int callnum, void *indata, int indlen,
void *outdata, int outdlen, nss_pheader_t *phdr)
{
void *uptr;
void *dptr;
void *datap;
size_t ndata;
size_t adata;
size_t buflen;
door_arg_t param;
int ret, errnum;
nss_pheader_t *phdr_d;
char *me = "_nscd_doorcall_fd";
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "processing door call %d (fd = %d)...\n", callnum, fd);
/* allocate door buffer from the stack */
NSCD_ALLOC_DOORBUF(callnum, indlen, uptr, buflen);
dptr = uptr;
ndata = buflen;
adata = buflen;
datap = NSCD_N2N_DOOR_DATA(void, dptr);
if (indata != NULL)
(void) memmove(datap, indata, indlen);
param.rbuf = (char *)dptr;
param.rsize = ndata;
param.data_ptr = (char *)dptr;
param.data_size = adata;
param.desc_ptr = NULL;
param.desc_num = 0;
ret = door_call(fd, ¶m);
if (ret < 0) {
errnum = errno;
/*
* door call did not get through, return errno
* if requested
*/
if (phdr != NULL) {
NSCD_SET_STATUS(phdr, NSS_ERROR, errnum);
}
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "door call (%d to %d) did not get through (%s)\n",
callnum, fd, strerror(errnum));
return (NSS_ERROR);
}
ndata = param.rsize;
dptr = (void *)param.data_ptr;
/*
* door call got through, check if operation failed.
* if so, return error info if requested
*/
phdr_d = (nss_pheader_t *)dptr;
ret = NSCD_GET_STATUS(phdr_d);
if (ret != NSS_SUCCESS) {
if (phdr != NULL) {
NSCD_COPY_STATUS(phdr, phdr_d);
}
_NSCD_LOG(NSCD_LOG_FRONT_END, NSCD_LOG_LEVEL_DEBUG)
(me, "door call (%d to %d) failed: p_status = %d, "
"p_errno = %s, nscd status = %d\n", callnum, fd,
ret, strerror(NSCD_GET_ERRNO(phdr_d)),
NSCD_GET_NSCD_STATUS(phdr_d));
} else
ret = copy_output(outdata, outdlen, phdr_d, phdr);
/* if new buffer allocated for this door call, free it */
if (dptr != uptr)
(void) munmap(dptr, param.rsize);
return (ret);
}
