/*ARGSUSED*/ static void event_handler(void *cookie, char *argp, size_t asize, door_desc_t *dp, uint_t n_desc) { door_cred_t cred; nvlist_t *nvlp; char *dtype; if (piclevent_debug) syslog(LOG_INFO, "piclevent: got SLM event cookie:%p evarg:%p size:0x%x\n", cookie, argp, asize); if ((door_id < 0) || (argp == NULL) || (door_cred(&cred) < 0) || (cred.dc_euid != 0)) (void) door_return(argp, 0, NULL, 0); if (nvlist_unpack(argp, asize, &nvlp, NULL)) (void) door_return(argp, 0, NULL, 0); if (nvlist_lookup_string(nvlp, PICLEVENTARG_DATA_TYPE, &dtype)) { nvlist_free(nvlp); (void) door_return(argp, 0, NULL, 0); } if (strcmp(dtype, PICLEVENTARG_PICLEVENT_DATA) == 0) parse_piclevent(nvlp); /* * ignore other event data types */ nvlist_free(nvlp); (void) door_return(argp, 0, NULL, 0); }
/*ARGSUSED*/ void fps_door_handler(void *cookie, char *argp, size_t asize, door_desc_t *dp, uint_t n_desc) { fps_event_t *evtp = NULL; fps_event_reply_t reply; reply.result = -1; /* -1 failure. 0 success */ if (argp == NULL) (void) door_return((char *)&reply, sizeof (reply), NULL, 0); /*LINTED*/ evtp = (fps_event_t *)argp; if (cookie != FPS_DOOR_COOKIE) (void) door_return((char *)&reply, sizeof (reply), NULL, 0); fpsd_message(FPSD_NO_EXIT, FPS_INFO, DOOR_HNDLR_MSG, evtp->version, evtp->type, evtp->length); reply.result = 0; (void) door_return((char *)&reply, sizeof (reply), NULL, 0); }
/* ARGSUSED */ static void vs_stats_door_call(void *cookie, char *ptr, size_t size, door_desc_t *dp, uint_t n_desc) { /* LINTED E_BAD_PTR_CAST_ALIGN */ vs_stats_req_t *req = (vs_stats_req_t *)ptr; vs_stats_rsp_t rsp; if ((cookie != &vs_stats_door_cookie) || (ptr == NULL) || (size != sizeof (vs_stats_req_t)) || (req->vsr_magic != VS_STATS_DOOR_MAGIC)) { return; } rsp.vsr_magic = VS_STATS_DOOR_MAGIC; switch (req->vsr_id) { case VS_STATS_GET: (void) pthread_mutex_lock(&vs_stats_mutex); rsp.vsr_stats = vscan_stats; (void) pthread_mutex_unlock(&vs_stats_mutex); (void) door_return((char *)&rsp, sizeof (vs_stats_rsp_t), NULL, 0); break; case VS_STATS_RESET: vs_stats_reset(); (void) door_return(NULL, 0, NULL, 0); break; default: return; } }
static void server_proc (void *cookie, char *argp, size_t arg_size, door_desc_t *dp, uint_t n_desc) { long arg; long res; if (argp == DOOR_UNREF_DATA) { printf ("Door unreferenced\n"); if (fattach (door_fd, door_path) == -1) err_msg ("fattach failed"); if (door_return (NULL, 0, NULL, 0) == -1) err_msg ("door_return failed"); } if (fdetach (door_path) == -1) err_msg("fdetach failed"); arg = *((long *) argp); res = arg * arg; printf ("Server proc returning, res = %ld\n", res); if (door_return ((char *) &res, sizeof (long), NULL, 0) == -1) err_msg ("door_return failed"); }
/* * Handles the door command IPMGMT_CMD_GETIF. It retrieves the name of all the * persisted interfaces and the IP protocols (IPv4 or IPv6) they support. */ static void ipmgmt_getif_handler(void *argp) { ipmgmt_getif_arg_t *getif = argp; ipmgmt_getif_rval_t *rvalp; ipmgmt_retval_t rval; ipmgmt_getif_cbarg_t cbarg; ipadm_if_info_t *ifp, *rifp, *curifp; int i, err = 0, count = 0; size_t rbufsize; assert(getif->ia_cmd == IPMGMT_CMD_GETIF); bzero(&cbarg, sizeof (cbarg)); cbarg.cb_ifname = getif->ia_ifname; err = ipmgmt_db_walk(ipmgmt_db_getif, &cbarg, IPADM_DB_READ); if (err == ENOENT && cbarg.cb_ifinfo) { /* * If there is atleast one entry in the nvlist, * do not return error. */ err = 0; } if (err != 0) { rval.ir_err = err; (void) door_return((char *)&rval, sizeof (rval), NULL, 0); return; } /* allocate sufficient buffer to return the interface info */ for (ifp = cbarg.cb_ifinfo; ifp != NULL; ifp = ifp->ifi_next) ++count; rbufsize = sizeof (*rvalp) + count * sizeof (*ifp); rvalp = alloca(rbufsize); bzero(rvalp, rbufsize); rvalp->ir_ifcnt = count; rifp = rvalp->ir_ifinfo; ifp = cbarg.cb_ifinfo; /* * copy the interface info to buffer allocated on stack. The reason * we do this is to avoid memory leak, as door_return() would never * return */ for (i = 0; i < count; i++) { rifp = rvalp->ir_ifinfo + i; (void) bcopy(ifp, rifp, sizeof (*rifp)); rifp->ifi_next = NULL; curifp = ifp->ifi_next; free(ifp); ifp = curifp; } rvalp->ir_err = err; (void) door_return((char *)rvalp, rbufsize, NULL, 0); }
static void if_selfcred_return_per_user_door(char *argp, size_t arg_size, door_desc_t *dp, int whoami) { nss_pheader_t *phdr = (nss_pheader_t *)((void *)argp); char *dblist; int door = -1; int rc = 0; door_desc_t desc; char *space; int len; /* * check to see if self-cred is configured and * need to return an alternate PUN door */ if (per_user_is_on == 1) { rc = need_per_user_door(argp, whoami, _nscd_get_client_euid(), &dblist); if (rc == -1) per_user_is_on = 0; } if (rc <= 0) { /* * self-cred not configured, and no error detected, * return to continue the door call processing */ if (NSCD_STATUS_IS_OK(phdr)) return; else /* * configured but error detected, * stop the door call processing */ (void) door_return(argp, phdr->data_off, NULL, 0); } /* get the alternate PUN door */ _nscd_proc_alt_get(argp, &door); if (NSCD_GET_STATUS(phdr) != NSS_ALTRETRY) { (void) door_return(argp, phdr->data_off, NULL, 0); } /* return the alternate door descriptor */ len = strlen(dblist) + 1; space = alloca(arg_size + len); phdr->data_len = len; (void) memcpy(space, phdr, arg_size); (void) strncpy((char *)space + arg_size, dblist, len); dp = &desc; dp->d_attributes = DOOR_DESCRIPTOR; dp->d_data.d_desc.d_descriptor = door; arg_size += len; (void) door_return(space, arg_size, dp, 1); }
/* * Handles the door command IPMGMT_CMD_GETADDR. It retrieves the persisted * address for a given `gargp->ia_aobjname'. If it is not defined then it * retrieves all the addresses configured on `gargp->ia_ifname'. The * "ipadm show-addr addrobj" or "ipadm show-addr <ifname>/\*" will call this * handler through library. */ static void ipmgmt_getaddr_handler(void *argp) { size_t buflen, onvlsize; char *buf, *onvlbuf; ipmgmt_getaddr_arg_t *gargp = argp; ipmgmt_getaddr_cbarg_t cbarg; ipmgmt_get_rval_t rval, *rvalp = &rval; int err = 0; cbarg.cb_ifname = gargp->ia_ifname; cbarg.cb_aobjname = gargp->ia_aobjname; cbarg.cb_ocnt = 0; if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0) goto fail; err = ipmgmt_db_walk(ipmgmt_db_getaddr, &cbarg, IPADM_DB_READ); if (err == ENOENT && cbarg.cb_ocnt > 0) { /* * If there is atleast one entry in the nvlist, * do not return error. */ err = 0; } if (err != 0) goto fail; if ((err = nvlist_size(cbarg.cb_onvl, &onvlsize, NV_ENCODE_NATIVE)) != 0) { goto fail; } buflen = onvlsize + sizeof (ipmgmt_get_rval_t); /* * We cannot use malloc() here because door_return never returns, and * memory allocated by malloc() would get leaked. Use alloca() instead. */ buf = alloca(buflen); onvlbuf = buf + sizeof (ipmgmt_get_rval_t); if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &onvlsize, NV_ENCODE_NATIVE, 0)) != 0) { goto fail; } nvlist_free(cbarg.cb_onvl); rvalp = (ipmgmt_get_rval_t *)(void *)buf; rvalp->ir_err = 0; rvalp->ir_nvlsize = onvlsize; (void) door_return(buf, buflen, NULL, 0); return; fail: nvlist_free(cbarg.cb_onvl); rvalp->ir_err = err; (void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0); }
static void reparsed_door_call_error(int error, int buflen) { reparsed_door_res_t rpd_res; memset(&rpd_res, 0, sizeof (reparsed_door_res_t)); rpd_res.res_status = error; rpd_res.res_len = buflen; door_return((char *)&rpd_res, sizeof (reparsed_door_res_t), NULL, 0); (void) door_return(NULL, 0, NULL, 0); /* NOTREACHED */ }
static void nfscmd_err(door_desc_t *dp, nfscmd_arg_t *args, int err) { nfscmd_res_t res; res.version = NFSCMD_VERS_1; res.cmd = NFSCMD_ERROR; res.error = err; (void) door_return((char *)&res, sizeof (nfscmd_res_t), NULL, 0); (void) door_return(NULL, 0, NULL, 0); /* NOTREACHED */ }
/* * picld_wait is called when a picl_wait request is received */ static void picld_wait(picl_service_t *in) { picl_retwait_t ret; int err; ucred_t *puc = NULL; uid_t uid; ret.cnum = in->req_wait.cnum; if (door_ucred(&puc) != 0) ret.retcode = PICL_FAILURE; else { uid = ucred_geteuid(puc); if (enter_picld_wait(uid) == PICL_FAILURE) ret.retcode = PICL_FAILURE; else { err = xptree_refresh_notify(in->req_wait.secs); ret.retcode = err; exit_picld_wait(uid); } ucred_free(puc); } (void) rw_unlock(&init_lk); (void) door_return((char *)&ret, sizeof (picl_retwait_t), NULL, 0); }
/* * Handles the door command IPMGMT_CMD_RESETADDR. For the given addrobj * deletes all the persisted addrobj configuration. It also deletes the * corresponding node, from `aobjmap'. */ static void ipmgmt_resetaddr_handler(void *argp) { ipmgmt_addr_arg_t *rargp = argp; ipmgmt_retval_t rval; ipmgmt_aobjmap_t node; uint32_t flags = rargp->ia_flags; int err = 0; ipmgmt_resetaddr_cbarg_t cbarg; cbarg.cb_aobjname = rargp->ia_aobjname; if (flags & IPMGMT_PERSIST) err = ipmgmt_db_walk(ipmgmt_db_resetaddr, &cbarg, IPADM_DB_DELETE); if (flags & IPMGMT_ACTIVE) { bzero(&node, sizeof (node)); (void) strlcpy(node.am_aobjname, rargp->ia_aobjname, sizeof (node.am_aobjname)); /* * am_lnum is used only for IPv6 autoconf case, since there * can be multiple nodes with the same aobjname. */ node.am_lnum = rargp->ia_lnum; node.am_flags = flags; (void) ipmgmt_aobjmap_op(&node, ADDROBJ_DELETE); } rval.ir_err = err; (void) door_return((char *)&rval, sizeof (rval), NULL, 0); }
/* ARGSUSED */ static void * doorserv_thread(void *arg) { (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); (void) door_return(NULL, 0, NULL, 0); return (NULL); }
/* ARGSUSED */ static void * picld_create_server_thread(void *arg) { /* * wait for door descriptor to be initialized */ (void) pthread_mutex_lock(&door_mutex); while (door_id == -1) { (void) pthread_cond_wait(&door_cv, &door_mutex); } (void) pthread_mutex_unlock(&door_mutex); /* * Bind this thread to the door's private thread pool */ if (door_bind(door_id) < 0) { perror("door_bind"); } /* * Disable thread cancellation mechanism */ (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); (void) door_return(NULL, 0, NULL, 0); /* wait for door invocation */ return (NULL); }
static void lookup(char *argp, size_t arg_size) { nsc_lookup_args_t largs; char space[NSCD_LOOKUP_BUFSIZE]; nss_pheader_t *phdr = (nss_pheader_t *)(void *)argp; NSCD_ALLOC_LOOKUP_BUFFER(argp, arg_size, phdr, space, sizeof (space)); /* * make sure the first couple bytes of the data area is null, * so that bad strings in the packed header stop here */ (void) memset((char *)phdr + phdr->data_off, 0, 16); (void) memset(&largs, 0, sizeof (largs)); largs.buffer = argp; largs.bufsize = arg_size; nsc_lookup(&largs, 0); /* * only the PUN needs to keep track of the * activity count to determine when to * terminate itself */ if (_whoami == NSCD_CHILD) { (void) mutex_lock(&activity_lock); ++activity; (void) mutex_unlock(&activity_lock); } NSCD_SET_RETURN_ARG(phdr, arg_size); (void) door_return(argp, arg_size, NULL, 0); }
/* * This function returns the property information */ static void picld_get_attrinfo(picl_service_t *in) { picl_retattrinfo_t ret; int err; ptree_propinfo_t pinfo; picl_prophdl_t ptreeh; err = cvt_picl2ptree(in->req_attrinfo.attr, &ptreeh); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); ret.cnum = PICL_CNUM_GETATTRINFO; ret.attr = in->req_attrinfo.attr; err = ptree_get_propinfo(ptreeh, &pinfo); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); ret.type = pinfo.piclinfo.type; ret.accessmode = pinfo.piclinfo.accessmode; ret.size = (uint32_t)pinfo.piclinfo.size; (void) strcpy(ret.name, pinfo.piclinfo.name); (void) rw_unlock(&init_lk); (void) door_return((char *)&ret, sizeof (picl_retattrinfo_t), NULL, 0); }
void fmd_door_server(void *dip) { fmd_dprintf(FMD_DBG_XPRT, "door server starting for %p\n", dip); (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); (void) door_return(NULL, 0, NULL, 0); }
/* ARGSUSED */ void doorHandler( void *cookie, char *args, size_t alen, door_desc_t *ddp, uint_t ndid) { uint32_t result = 0; if (ddp != NULL || ndid != 0) { syslog(LOG_DAEMON|LOG_WARNING, "descriptor passed to door %p %d", ddp, ndid); result = EINVAL; } if (args == NULL || alen == 0) { syslog(LOG_DAEMON|LOG_WARNING, "empty message passed to door %p %d", args, alen); result = EFAULT; } if (result == 0) result = postMsg((uint_t)alen, (uchar_t *)args); (void) door_return((char *)&result, sizeof (result), NULL, 0); syslog(LOG_DAEMON|LOG_WARNING, "door_return FAILED %d", errno); exit(errno); }
/* * This function returns the value of the PICL property specified by * its name. */ static void picld_get_attrval_by_name(picl_service_t *in) { picl_retattrvalbyname_t *ret; int err; size_t vbufsize; size_t len; door_cred_t cred; picl_nodehdl_t ptreeh; ptree_propinfo_t pinfo; if (door_cred(&cred) < 0) picld_return_error(in->in.cnum, PICL_FAILURE); err = cvt_picl2ptree(in->req_attrvalbyname.nodeh, &ptreeh); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); err = xptree_get_propinfo_by_name(ptreeh, in->req_attrvalbyname.propname, &pinfo); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); if (!(pinfo.piclinfo.accessmode & PICL_READ)) picld_return_error(in->in.cnum, PICL_NOTREADABLE); /* * allocate the minimum of piclinfo.size and input bufsize */ vbufsize = pinfo.piclinfo.size; vbufsize = MIN((size_t)in->req_attrvalbyname.bufsize, vbufsize); len = sizeof (picl_retattrvalbyname_t) + vbufsize; ret = alloca(len); if (ret == NULL) picld_return_error(in->in.cnum, PICL_FAILURE); ret->cnum = PICL_CNUM_GETATTRVALBYNAME; ret->nodeh = in->req_attrvalbyname.nodeh; (void) strcpy(ret->propname, in->req_attrvalbyname.propname); ret->nbytes = (uint32_t)vbufsize; err = xptree_get_propval_by_name_with_cred(ptreeh, in->req_attrvalbyname.propname, ret->ret_buf, vbufsize, cred); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); /* * adjust returned value size for charstrings */ if (pinfo.piclinfo.type == PICL_PTYPE_CHARSTRING) ret->nbytes = (uint32_t)strlen(ret->ret_buf) + 1; if ((pinfo.piclinfo.type == PICL_PTYPE_TABLE) || (pinfo.piclinfo.type == PICL_PTYPE_REFERENCE)) cvt_ptree2picl(&ret->ret_nodeh); (void) rw_unlock(&init_lk); (void) door_return((char *)ret, sizeof (picl_retattrvalbyname_t) + (size_t)ret->nbytes, NULL, 0); }
/* * Handles the door command IPMGMT_CMD_SETIF. It persists the interface * information in the DB. */ static void ipmgmt_setif_handler(void *argp) { ipmgmt_retval_t rval; rval.ir_err = ipmgmt_persist_if(argp); (void) door_return((char *)&rval, sizeof (rval), NULL, 0); }
/* * This function returns the value of the PICL property */ static void picld_get_attrval(picl_service_t *in) { picl_retattrval_t *ret; int err; size_t vbufsize; size_t len; door_cred_t cred; picl_prophdl_t ptreeh; ptree_propinfo_t pinfo; if (door_cred(&cred) < 0) picld_return_error(in->in.cnum, PICL_FAILURE); err = cvt_picl2ptree(in->req_attrval.attr, &ptreeh); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); err = ptree_get_propinfo(ptreeh, &pinfo); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); if (!(pinfo.piclinfo.accessmode & PICL_READ)) picld_return_error(in->in.cnum, PICL_NOTREADABLE); vbufsize = pinfo.piclinfo.size; vbufsize = MIN((size_t)in->req_attrval.bufsize, vbufsize); len = sizeof (picl_retattrval_t) + vbufsize; ret = alloca(len); if (ret == NULL) picld_return_error(in->in.cnum, PICL_FAILURE); ret->cnum = PICL_CNUM_GETATTRVAL; ret->attr = in->req_attrval.attr; ret->nbytes = (uint32_t)vbufsize; err = xptree_get_propval_with_cred(ptreeh, ret->ret_buf, vbufsize, cred); if (err != PICL_SUCCESS) picld_return_error(in->in.cnum, err); /* * adjust returned bytes for charstrings */ if (pinfo.piclinfo.type == PICL_PTYPE_CHARSTRING) ret->nbytes = (uint32_t)strlen(ret->ret_buf) + 1; /* * convert handle values to picl handles */ if ((pinfo.piclinfo.type == PICL_PTYPE_TABLE) || (pinfo.piclinfo.type == PICL_PTYPE_REFERENCE)) cvt_ptree2picl(&ret->ret_nodeh); (void) rw_unlock(&init_lk); (void) door_return((char *)ret, sizeof (picl_retattrval_t) + (size_t)ret->nbytes, NULL, 0); }
static void picld_ping(picl_service_t *in) { picl_retping_t ret; ret.cnum = in->req_ping.cnum; (void) rw_unlock(&init_lk); (void) door_return((char *)&ret, sizeof (picl_retping_t), NULL, 0); }
/* ARGSUSED */ static void event_handler(void *cookie, char *argp, size_t asize, door_desc_t *dp, uint_t n_desc) { wpa_event_type event; event = ((wl_events_t *)argp)->event; wpa_event_handler(cookie, event); (void) door_return(NULL, 0, NULL, 0); }
static void nfscmd_charmap_lookup(door_desc_t *dp, nfscmd_arg_t *args) { nfscmd_res_t res; struct netbuf nb; struct sockaddr sa; struct share *sh = NULL; char *opts; char *name; memset(&res, '\0', sizeof (res)); res.version = NFSCMD_VERS_1; res.cmd = NFSCMD_CHARMAP_LOOKUP; sh = findentry(args->arg.charmap.path); if (sh != NULL) { nb.len = nb.maxlen = sizeof (struct sockaddr); nb.buf = (char *)&sa; sa = args->arg.charmap.addr; name = charmap_search(&nb, sh->sh_opts); if (name != NULL) { strcpy(res.result.charmap.codeset, name); res.result.charmap.apply = B_TRUE; res.error = NFSCMD_ERR_SUCCESS; free(name); } else { res.result.charmap.apply = B_FALSE; res.error = NFSCMD_ERR_NOTFOUND; } sharefree(sh); } else { res.error = NFSCMD_ERR_NOTFOUND; } (void) door_return((char *)&res, sizeof (nfscmd_res_t), NULL, 0); (void) door_return(NULL, 0, NULL, 0); /* NOTREACHED */ }
/* * Handles the door command IPMGMT_CMD_RESETPROP. It deletes the property line * from the DB. */ static void ipmgmt_resetprop_handler(void *argp) { ipmgmt_prop_arg_t *pargp = argp; ipmgmt_retval_t rval; assert(pargp->ia_cmd == IPMGMT_CMD_RESETPROP); rval.ir_err = ipmgmt_db_walk(ipmgmt_db_resetprop, pargp, IPADM_DB_DELETE); (void) door_return((char *)&rval, sizeof (rval), NULL, 0); }
/* * This returns an error message to libpicl */ static void picld_return_error(picl_callnumber_t cnum, picl_errno_t err) { picl_reterror_t ret_error; ret_error.cnum = PICL_CNUM_ERROR; ret_error.in_cnum = cnum; ret_error.errnum = err; (void) rw_unlock(&init_lk); (void) door_return((char *)&ret_error, sizeof (picl_reterror_t), NULL, 0); }
static void server_proc (void *cookie, char *argp, size_t arg_size, door_desc_t *dp, uint_t n_desc) { long arg; long res; arg = *((long *) argp); res = arg * arg; if (door_return ((char *) &res, sizeof (long), NULL, 0) == -1) err_msg ("door_return failed"); }
/* ARGSUSED */ void nfsmapid_func(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, uint_t n_desc) { struct mapid_arg *mapargp; struct mapid_res mapres; /* * Make sure we have a valid argument */ if (arg_size < sizeof (struct mapid_arg)) { mapres.status = NFSMAPID_INVALID; mapres.u_res.len = 0; (void) door_return((char *)&mapres, sizeof (struct mapid_res), NULL, 0); return; } /* LINTED pointer cast */ mapargp = (struct mapid_arg *)argp; switch (mapargp->cmd) { case NFSMAPID_STR_UID: nfsmapid_str_uid(mapargp, arg_size); return; case NFSMAPID_UID_STR: nfsmapid_uid_str(mapargp, arg_size); return; case NFSMAPID_STR_GID: nfsmapid_str_gid(mapargp, arg_size); return; case NFSMAPID_GID_STR: nfsmapid_gid_str(mapargp, arg_size); return; default: break; } mapres.status = NFSMAPID_INVALID; mapres.u_res.len = 0; (void) door_return((char *)&mapres, sizeof (struct mapid_res), NULL, 0); }
static void getent(char *argp, size_t arg_size) { char space[NSCD_LOOKUP_BUFSIZE]; nss_pheader_t *phdr = (nss_pheader_t *)(void *)argp; NSCD_ALLOC_LOOKUP_BUFFER(argp, arg_size, phdr, space, sizeof (space)); nss_pgetent(argp, arg_size); NSCD_SET_RETURN_ARG(phdr, arg_size); (void) door_return(argp, arg_size, NULL, 0); }
/*ARGSUSED*/ static void * server_tsd_bind(void *arg) { static void *value = 0; /* disable cancellation to avoid hangs if server threads disappear */ (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); (void) thr_setspecific(server_key, value); (void) door_return(NULL, 0, NULL, 0); /* make lint happy */ return (NULL); }
void nfscmd_func(void *cookie, char *dataptr, size_t arg_size, door_desc_t *dp, uint_t n_desc) { nfscmd_arg_t *args; args = (nfscmd_arg_t *)dataptr; switch (args->version) { case NFSCMD_VERS_1: nfscmd_vers_1(dp, args, arg_size); break; default: syslog(LOG_ERR, gettext("Invalid nfscmd version")); break; } (void) door_return((caddr_t)args, sizeof (nfscmd_res_t), NULL, 0); (void) door_return(NULL, 0, NULL, 0); /* NOTREACHED */ }