/*
 * 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.
 */

/*
 * PICL daemon
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <libintl.h>
#include <locale.h>
#include <alloca.h>
#include <errno.h>
#include <assert.h>
#include <stropts.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <synch.h>
#include <door.h>
#include <sys/door.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <time.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <dirent.h>
#include <syslog.h>
#include <poll.h>
#include <limits.h>
#include <picl.h>
#include "picl2door.h"
#include <picltree.h>
#include "ptree_impl.h"

/*
 * Log text messages
 */
#define MUST_BE_ROOT    gettext("this program must be run as root\n")
#define CD_ROOT_FAILED  gettext("chdir to root failed\n")
#define INIT_FAILED     gettext("ptree initialization failed\n")
#define DAEMON_RUNNING  gettext("PICL daemon already running\n")
#define DOOR_FAILED     gettext("Failed creating picld door\n")
#define SIGACT_FAILED   \
                gettext("Failed to install signal handler for %s: %s\n")

/*
 * Constants
 */
#define PICLD                           "picld"
#define DOS_PICL_REQUESTS_LIMIT         10000
#define SLIDING_INTERVAL_MILLISECONDS   1000
#define PICLD_MAJOR_REV                 0x1
#define PICLD_MINOR_REV                 0x0
#define DOS_SLEEPTIME_MS                1000
#define MAX_POOL_SIZE                   _POSIX_THREAD_THREADS_MAX
#define MAX_CONCURRENT_WAITS    (_POSIX_THREAD_THREADS_MAX - 2)
#define MAX_USER_WAITS                  4

/*
 * Macros
 */
#define PICLD_VERSION(x, y)     ((x << 8) | y)
#define PICL_CLIENT_REV(x)      (x & 0xff)
#define MILLI_TO_NANO(x)        (x * 1000000)

extern  char    **environ;

/*
 * Module Variables
 */
static  int             logflag = 1;
static  int             doreinit = 0;
static  int             door_id = -1;
static  pthread_mutex_t door_mutex = PTHREAD_MUTEX_INITIALIZER;
static  pthread_cond_t door_cv = PTHREAD_COND_INITIALIZER;
static  int             service_requests = 0;
static  hrtime_t        orig_time;
static  hrtime_t        sliding_interval_ms;
static  uint32_t        dos_req_limit;
static  uint32_t        dos_ms;
static  pthread_mutex_t dos_mutex = PTHREAD_MUTEX_INITIALIZER;
static  rwlock_t        init_lk;
static  int pool_count = 0;
static  pthread_mutex_t pool_mutex = PTHREAD_MUTEX_INITIALIZER;
static  pthread_mutex_t wait_req_mutex = PTHREAD_MUTEX_INITIALIZER;
static  int wait_count = 0;
static  struct {
        uid_t uid;
        int count;
} user_count[MAX_CONCURRENT_WAITS];

/*
 * 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);
}

/*
 * picld_init is called when a picl_initialize request is received
 */
static void
picld_init(picl_service_t *req)
{
        picl_retinit_t  ret_init;
        int     clmajrev;

        clmajrev = PICL_CLIENT_REV(req->req_init.clrev);

        if (clmajrev < PICL_VERSION_1)
                picld_return_error(req->req_init.cnum, PICL_NOTSUPPORTED);

        ret_init.cnum = req->req_init.cnum;
        ret_init.rev = PICLD_VERSION(PICLD_MAJOR_REV, PICLD_MINOR_REV);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret_init, sizeof (picl_retinit_t), NULL, 0);
}

/*
 * picld_fini is called when a picl_shutdown request is received
 */
static void
picld_fini(picl_service_t *in)
{
        picl_retfini_t  ret;

        ret.cnum = in->req_fini.cnum;

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retfini_t), 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);
}

static int
check_user(uid_t uid)
{
        int i;
        uid_t tmp_uid;
        int free_idx = -1;

        if (uid == 0)
                return (PICL_SUCCESS);
        for (i = 0; i < MAX_CONCURRENT_WAITS; i++) {
                if ((tmp_uid = user_count[i].uid) == uid) {
                        if (user_count[i].count == MAX_USER_WAITS)
                                return (PICL_FAILURE);
                        user_count[i].count++;
                        return (PICL_SUCCESS);
                }
                if ((free_idx == -1) && (tmp_uid == 0))
                        free_idx = i;
        }
        if (free_idx != -1) {
                user_count[free_idx].uid = uid;
                user_count[free_idx].count = 1;
                return (PICL_SUCCESS);
        }
        return (PICL_FAILURE);
}

static void
done_user(uid_t uid)
{
        int i;

        if (uid == 0)
                return;
        for (i = 0; i < MAX_CONCURRENT_WAITS; i++) {
                if (user_count[i].uid == uid) {
                        if (--user_count[i].count == 0)
                                user_count[i].uid = 0;
                        return;
                }
        }
}

static int
enter_picld_wait(uid_t uid)
{
        int     rv;

        if (pthread_mutex_lock(&wait_req_mutex) != 0)
                return (PICL_FAILURE);
        if ((wait_count < MAX_CONCURRENT_WAITS) &&
            (check_user(uid) == PICL_SUCCESS)) {
                rv = PICL_SUCCESS;
                wait_count++;
        } else {
                rv = PICL_FAILURE;
        }
        (void) pthread_mutex_unlock(&wait_req_mutex);
        return (rv);
}

static void
exit_picld_wait(uid_t uid)
{
        (void) pthread_mutex_lock(&wait_req_mutex);
        done_user(uid);
        wait_count--;
        (void) pthread_mutex_unlock(&wait_req_mutex);
}

/*
 * 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);
}

/*
 * This function returns the handle of the root node of the PICL tree
 */
static void
picld_getroot(picl_service_t *in)
{
        picl_retroot_t  ret;
        int             err;

        ret.cnum = PICL_CNUM_GETROOT;
        err = ptree_get_root(&ret.rnode);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);
        cvt_ptree2picl(&ret.rnode);
        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retroot_t), 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);
}

/*
 * 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);
}

/*
 * This function sets a property value
 */
static void
picld_set_attrval(picl_service_t *in)
{
        picl_retsetattrval_t    ret;
        int                     err;
        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_setattrval.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_WRITE))
                picld_return_error(in->in.cnum, PICL_NOTWRITABLE);
        /*
         * For non-volatile prop, only super user can set its value.
         */
        if (!(pinfo.piclinfo.accessmode & PICL_VOLATILE) &&
            (cred.dc_euid != SUPER_USER))
                picld_return_error(in->in.cnum, PICL_PERMDENIED);

        ret.cnum = PICL_CNUM_SETATTRVAL;
        ret.attr = in->req_setattrval.attr;

        err = xptree_update_propval_with_cred(ptreeh, in->req_setattrval.valbuf,
            (size_t)in->req_setattrval.bufsize, cred);

        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retsetattrval_t), NULL,
            0);
}

/*
 * This function sets the value of a property specified by its name.
 */
static void
picld_set_attrval_by_name(picl_service_t *in)
{
        picl_retsetattrvalbyname_t      ret;
        int                             err;
        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_setattrvalbyname.nodeh, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        err = xptree_get_propinfo_by_name(ptreeh,
            in->req_setattrvalbyname.propname, &pinfo);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        if (!(pinfo.piclinfo.accessmode & PICL_WRITE))
                picld_return_error(in->in.cnum, PICL_NOTWRITABLE);

        /*
         * For non-volatile prop, only super user can set its value.
         */
        if (!(pinfo.piclinfo.accessmode & PICL_VOLATILE) &&
            (cred.dc_euid != SUPER_USER))
                picld_return_error(in->in.cnum, PICL_PERMDENIED);

        ret.cnum = PICL_CNUM_SETATTRVALBYNAME;
        ret.nodeh = in->req_setattrvalbyname.nodeh;
        (void) strcpy(ret.propname, in->req_setattrvalbyname.propname);

        err = xptree_update_propval_by_name_with_cred(ptreeh,
            in->req_setattrvalbyname.propname,
            in->req_setattrvalbyname.valbuf,
            (size_t)in->req_setattrvalbyname.bufsize,
            cred);

        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retsetattrvalbyname_t),
            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);
}

/*
 * This function returns the node's first property handle
 */
static void
picld_get_first_attr(picl_service_t *in)
{
        picl_retfirstattr_t     ret;
        int                     err;
        picl_prophdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_firstattr.nodeh, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_GETFIRSTATTR;
        ret.nodeh = in->req_firstattr.nodeh;

        err = ptree_get_first_prop(ptreeh, &ret.attr);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);
        cvt_ptree2picl(&ret.attr);
        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retfirstattr_t), NULL, 0);
}

/*
 * This function returns the next property handle in list
 */
static void
picld_get_next_attr(picl_service_t *in)
{
        picl_retnextattr_t      ret;
        int                     err;
        picl_prophdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_nextattr.attr, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_GETNEXTATTR;
        ret.attr = in->req_nextattr.attr;

        err = ptree_get_next_prop(ptreeh, &ret.nextattr);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        cvt_ptree2picl(&ret.nextattr);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retnextattr_t), NULL, 0);
}

/*
 * This function returns the handle of a property specified by its name
 */
static void
picld_get_attr_by_name(picl_service_t *in)
{
        picl_retattrbyname_t    ret;
        int                     err;
        picl_prophdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_attrbyname.nodeh, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_GETATTRBYNAME;
        ret.nodeh = in->req_attrbyname.nodeh;
        (void) strcpy(ret.propname, in->req_attrbyname.propname);

        err = ptree_get_prop_by_name(ptreeh, ret.propname, &ret.attr);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        cvt_ptree2picl(&ret.attr);
        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retattrbyname_t), NULL,
            0);
}

/*
 * This function gets the next property on the same row in the table
 */
static void
picld_get_attr_by_row(picl_service_t *in)
{
        picl_retattrbyrow_t     ret;
        int                     err;
        picl_prophdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_attrbyrow.attr, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_GETATTRBYROW;
        ret.attr = in->req_attrbyrow.attr;

        err = ptree_get_next_by_row(ptreeh, &ret.rowattr);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);
        cvt_ptree2picl(&ret.rowattr);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retattrbyrow_t), NULL, 0);
}

/*
 * This function returns the handle of the next property in the same column
 * of the table.
 */
static void
picld_get_attr_by_col(picl_service_t *in)
{
        picl_retattrbycol_t     ret;
        int                     err;
        picl_prophdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_attrbycol.attr, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_GETATTRBYCOL;
        ret.attr = in->req_attrbycol.attr;

        err = ptree_get_next_by_col(ptreeh, &ret.colattr);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        cvt_ptree2picl(&ret.colattr);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (picl_retattrbycol_t), NULL, 0);
}

/*
 * This function finds the node in the PICLTREE that matches the given
 * criteria and returns its handle.
 */
static void
picld_find_node(picl_service_t *in)
{
        picl_retfindnode_t      ret;
        int                     err;
        picl_nodehdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_findnode.nodeh, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_FINDNODE;

        err = ptree_find_node(ptreeh, in->req_findnode.propname,
            in->req_findnode.ptype, in->req_findnode.valbuf,
            in->req_findnode.valsize, &ret.rnodeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        cvt_ptree2picl(&ret.rnodeh);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (ret), NULL, 0);
}

/*
 * This function finds the property/node that corresponds to the given path
 * and returns its handle
 */
static void
picld_get_node_by_path(picl_service_t *in)
{
        picl_retnodebypath_t    ret;
        int                     err;

        ret.cnum = PICL_CNUM_NODEBYPATH;
        err = ptree_get_node_by_path(in->req_nodebypath.pathbuf, &ret.nodeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);
        cvt_ptree2picl(&ret.nodeh);
        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (ret), NULL, 0);
}

/*
 * This function returns finds the frutree parent node for a given node
 * and returns its handle
 */
static void
picld_get_frutree_parent(picl_service_t *in)
{
        picl_retfruparent_t     ret;
        int                     err;
        picl_nodehdl_t          ptreeh;

        err = cvt_picl2ptree(in->req_fruparent.devh, &ptreeh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);

        ret.cnum = PICL_CNUM_FRUTREEPARENT;

        err = ptree_get_frutree_parent(ptreeh, &ret.fruh);
        if (err != PICL_SUCCESS)
                picld_return_error(in->in.cnum, err);
        cvt_ptree2picl(&ret.fruh);

        (void) rw_unlock(&init_lk);
        (void) door_return((char *)&ret, sizeof (ret), NULL, 0);
}

/*
 * This function is called when an unknown client request is received.
 */
static void
picld_unknown_service(picl_service_t *in)
{
        picld_return_error(in->in.cnum, PICL_UNKNOWNSERVICE);
}

static void
check_denial_of_service(int cnum)
{
        hrtime_t        window;
        hrtime_t        current;
        int             dos_flag;

        current = gethrtime();
        dos_flag = 0;

        if (pthread_mutex_lock(&dos_mutex) != 0)
                picld_return_error(cnum, PICL_FAILURE);

        ++service_requests;
        window = current - orig_time;
        if (window > MILLI_TO_NANO(sliding_interval_ms)) {
                orig_time = current;
                service_requests = 1;
        }

        if (service_requests > dos_req_limit)
                dos_flag = 1;

        if (pthread_mutex_unlock(&dos_mutex) != 0)
                picld_return_error(cnum, PICL_FAILURE);

        if (dos_flag)
                (void) poll(NULL, 0, dos_ms);
}

/* ARGSUSED */
static void
picld_door_handler(void *cookie, char *argp, size_t asize,
    door_desc_t *dp, uint_t n_desc)
{
        picl_service_t  *req;

        /*LINTED*/
        req = (picl_service_t *)argp;

        if (req == NULL)
                (void) door_return((char *)req, 0, NULL, 0);

        check_denial_of_service(req->in.cnum);

        (void) rw_rdlock(&init_lk);
        switch (req->in.cnum) { /* client call number */
        case PICL_CNUM_INIT:
                /*LINTED*/
                picld_init((picl_service_t *)argp);
                break;
        case PICL_CNUM_FINI:
                /*LINTED*/
                picld_fini((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETROOT:
                /*LINTED*/
                picld_getroot((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRVAL:
                /*LINTED*/
                picld_get_attrval((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRVALBYNAME:
                /*LINTED*/
                picld_get_attrval_by_name((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRINFO:
                /*LINTED*/
                picld_get_attrinfo((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETFIRSTATTR:
                /*LINTED*/
                picld_get_first_attr((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETNEXTATTR:
                /*LINTED*/
                picld_get_next_attr((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRBYNAME:
                /*LINTED*/
                picld_get_attr_by_name((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRBYROW:
                /*LINTED*/
                picld_get_attr_by_row((picl_service_t *)argp);
                break;
        case PICL_CNUM_GETATTRBYCOL:
                /*LINTED*/
                picld_get_attr_by_col((picl_service_t *)argp);
                break;
        case PICL_CNUM_SETATTRVAL:
                /*LINTED*/
                picld_set_attrval((picl_service_t *)argp);
                break;
        case PICL_CNUM_SETATTRVALBYNAME:
                /*LINTED*/
                picld_set_attrval_by_name((picl_service_t *)argp);
                break;
        case PICL_CNUM_PING:
                /*LINTED*/
                picld_ping((picl_service_t *)argp);
                break;
        case PICL_CNUM_WAIT:
                /*LINTED*/
                picld_wait((picl_service_t *)argp);
                break;
        case PICL_CNUM_FINDNODE:
                /*LINTED*/
                picld_find_node((picl_service_t *)argp);
                break;
        case PICL_CNUM_NODEBYPATH:
                /*LINTED*/
                picld_get_node_by_path((picl_service_t *)argp);
                break;
        case PICL_CNUM_FRUTREEPARENT:
                /*LINTED*/
                picld_get_frutree_parent((picl_service_t *)argp);
                break;
        default:
                /*LINTED*/
                picld_unknown_service((picl_service_t *)argp);
                break;
        };
        /*NOTREACHED*/
}

/* ARGSUSED */
static void
hup_handler(int sig, siginfo_t *siginfo, void *sigctx)
{
        doreinit = 1;
}

/*
 * "ping" to see if a daemon is already running
 */
static int
daemon_exists(void)
{
        door_arg_t      darg;
        picl_reqping_t  req_ping;
        picl_retping_t  ret_ping;
        int             doorh;
        door_info_t     dinfo;

        doorh = open(PICLD_DOOR, O_RDONLY);
        if (doorh < 0)
                return (0);

        if (door_info(doorh, &dinfo) < 0) {
                (void) close(doorh);
                return (0);
        }

        if ((dinfo.di_attributes & DOOR_REVOKED) ||
            (dinfo.di_data != (uintptr_t)PICLD_DOOR_COOKIE)) {
                (void) close(doorh);
                return (0);
        }

        if (dinfo.di_target != getpid()) {
                (void) close(doorh);
                return (1);
        }

        req_ping.cnum = PICL_CNUM_PING;

        darg.data_ptr = (char *)&req_ping;
        darg.data_size = sizeof (picl_reqping_t);
        darg.desc_ptr = NULL;
        darg.desc_num = 0;
        darg.rbuf = (char *)&ret_ping;
        darg.rsize = sizeof (picl_retping_t);

        if (door_call(doorh, &darg) < 0) {
                (void) close(doorh);
                return (0);
        }

        (void) close(doorh);
        return (1);
}

/*
 * picld_create_server_thread - binds the running thread to the private
 * door pool, and sets the required cancellation state.
 */
/* 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);
}

/*
 * picld_server_create_fn - creates threads for the private door pool
 *
 */
/* ARGSUSED */
static void
picld_server_create_fn(door_info_t *dip)
{
        pthread_attr_t attr;

        /*
         * For the non-private pool do nothing. It's used for events which are
         * single threaded anyway. The single thread servicing that pool is
         * created when the event plugin creates its door. Note that the event
         * plugin runs before setup_door instantiates picld_server_create_fn as
         * the new create_proc so the door library default create_proc is used.
         */
        if (dip == NULL)
                return;

        (void) pthread_mutex_lock(&pool_mutex);
        if (pool_count < MAX_POOL_SIZE) {
                (void) pthread_attr_init(&attr);
                (void) pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
                (void) pthread_attr_setdetachstate(&attr,
                    PTHREAD_CREATE_DETACHED);
                if (pthread_create(NULL, &attr, picld_create_server_thread,
                    NULL)) {
                        perror("pthread_create");
                } else {
                        pool_count++;
                }
        }
        (void) pthread_mutex_unlock(&pool_mutex);
}

/*
 * Create the picld door
 */
static int
setup_door(void)
{
        struct stat     stbuf;

        (void) door_server_create(picld_server_create_fn);
        (void) pthread_mutex_lock(&door_mutex);
        /*
         * Create the door
         */
        door_id = door_create(picld_door_handler, PICLD_DOOR_COOKIE,
            DOOR_REFUSE_DESC | DOOR_NO_CANCEL | DOOR_PRIVATE);

        if (door_id < 0) {
                (void) pthread_mutex_unlock(&door_mutex);
                return (-1);
        } else {
                (void) pthread_cond_signal(&door_cv);
                (void) pthread_mutex_unlock(&door_mutex);
        }

        if (stat(PICLD_DOOR, &stbuf) < 0) {
                int newfd;
                mode_t old_mask;
                /* ensure that the door file is world-readable */
                old_mask = umask(0);
                newfd = creat(PICLD_DOOR, 0444);
                /* restore the file mode creation mask */
                (void) umask(old_mask);
                if (newfd < 0)
                        return (-1);
                (void) close(newfd);
        }

        if (fattach(door_id, PICLD_DOOR) < 0) {
                if ((errno != EBUSY) ||
                    (fdetach(PICLD_DOOR) < 0) ||
                    (fattach(door_id, PICLD_DOOR) < 0))
                        return (-1);
        }
        return (0);
}

/*
 * Main function of picl daemon
 */
int
main(int argc, char **argv)
{
        struct  sigaction       act;
        int                     c;
        sigset_t                ublk;


        (void) setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);

        if (getuid() != 0) {
                syslog(LOG_CRIT, MUST_BE_ROOT);
                return (0);
        }

        (void) rwlock_init(&init_lk, USYNC_THREAD, NULL);
        doreinit = 0;
        logflag = 1;
        dos_req_limit = DOS_PICL_REQUESTS_LIMIT;
        sliding_interval_ms = SLIDING_INTERVAL_MILLISECONDS;
        dos_ms = DOS_SLEEPTIME_MS;
        verbose_level = 0;

        /*
         * parse arguments
         */
        while ((c = getopt(argc, argv, "is:t:l:r:v:d:")) != EOF) {
                switch (c) {
                case 'd':
                        dos_ms = strtol(optarg, (char **)NULL, 0);
                        break;
                case 'i':
                        logflag = 0;
                        break;
                case 's':
                        sliding_interval_ms = strtoll(optarg, (char **)NULL, 0);
                        break;
                case 't':
                        dos_req_limit = strtol(optarg, (char **)NULL, 0);
                        break;
                case 'v':
                        verbose_level = strtol(optarg, (char **)NULL, 0);
                        logflag = 0;
                        break;
                default:
                        break;
                }
        }

        orig_time = gethrtime();

        /*
         * is there a daemon already running?
         */

        if (daemon_exists()) {
                syslog(LOG_CRIT, DAEMON_RUNNING);
                exit(1);
        }

        /*
         * Mask off/block SIGALRM signal so that the environmental plug-in
         * (piclenvd) can use it to simulate sleep() without being affected
         * by time being set back. No other PICL plug-in should use SIGALRM
         * or alarm() for now.
         */
        (void) sigemptyset(&ublk);
        (void) sigaddset(&ublk, SIGALRM);
        (void) sigprocmask(SIG_BLOCK, &ublk, NULL);

        /*
         * Ignore SIGHUP until all the initialization is done.
         */
        act.sa_handler = SIG_IGN;
        (void) sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        if (sigaction(SIGHUP, &act, NULL) == -1)
                syslog(LOG_ERR, SIGACT_FAILED, strsignal(SIGHUP),
                    strerror(errno));

        if (logflag != 0) {     /* daemonize */
                pid_t pid;

                pid = fork();
                if (pid < 0)
                        exit(1);
                if (pid > 0)
                        /* parent */
                        exit(0);

                /* child */
                if (chdir("/") == -1) {
                        syslog(LOG_CRIT, CD_ROOT_FAILED);
                        exit(1);
                }

                (void) setsid();
                closefrom(0);
                (void) open("/dev/null", O_RDWR, 0);
                (void) dup2(STDIN_FILENO, STDOUT_FILENO);
                (void) dup2(STDIN_FILENO, STDERR_FILENO);
                openlog(PICLD, LOG_PID, LOG_DAEMON);
        }

        /*
         * Initialize the PICL Tree
         */
        if (xptree_initialize(0) != PICL_SUCCESS) {
                syslog(LOG_CRIT, INIT_FAILED);
                exit(1);
        }

        if (setup_door()) {
                syslog(LOG_CRIT, DOOR_FAILED);
                exit(1);
        }

        /*
         * setup signal handlers for post-init
         */
        act.sa_sigaction = hup_handler;
        (void) sigemptyset(&act.sa_mask);
        act.sa_flags = SA_SIGINFO;
        if (sigaction(SIGHUP, &act, NULL) == -1)
                syslog(LOG_ERR, SIGACT_FAILED, strsignal(SIGHUP),
                    strerror(errno));

        /*
         * wait for requests
         */
        for (;;) {
                (void) pause();
                if (doreinit) {
                        /*
                         * Block SIGHUP during reinitialization.
                         * Also mask off/block SIGALRM signal so that the
                         * environmental plug-in (piclenvd) can use it to
                         * simulate sleep() without being affected by time
                         * being set back. No ohter PICL plug-in should use
                         * SIGALRM or alarm() for now.
                         */
                        (void) sigemptyset(&ublk);
                        (void) sigaddset(&ublk, SIGHUP);
                        (void) sigaddset(&ublk, SIGALRM);
                        (void) sigprocmask(SIG_BLOCK, &ublk, NULL);
                        (void) sigdelset(&ublk, SIGALRM);
                        doreinit = 0;
                        (void) rw_wrlock(&init_lk);
                        xptree_destroy();
                        (void) xptree_reinitialize();
                        (void) rw_unlock(&init_lk);
                        (void) sigprocmask(SIG_UNBLOCK, &ublk, NULL);
                }
        }
}