/***************************************************************************
 *
 * addon-cpufreq.c : Routines to support CPUFreq interface
 *
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/dkio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <glib.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus-glib.h>
#include <priv.h>
#include <pwd.h>

#include <syslog.h>

#include <libhal.h>
#include "../../hald/logger.h"
#include "../../utils/adt_data.h"

#include <pwd.h>
#ifdef HAVE_POLKIT
#include <libpolkit.h>
#endif

#ifdef sun
#include <bsm/adt.h>
#include <bsm/adt_event.h>
#include <sys/pm.h>
#endif

#define POWER_CONF_FILE "/etc/power.conf"
#define PMCONFIG "/usr/sbin/pmconfig -f"
#define PM "/dev/pm"

#define FILE_ARR_SIZE 256
#define EDIT_TYPE_SIZE 64
#define ERR_BUF_SIZE 256

#define WAIT_TIME 30

char TMP_CONF_FILE[64] = "/tmp/power.conf.XXXXXX";
const char *sender;
unsigned long uid;

/*
 * Specify different CPUFreq related HAL activities that can be done
 */
enum hal_type {
        CPU_GOV,
        CPU_PERFORMANCE
};
typedef enum hal_type power_conf_hal_type;

/*
 * Various CPUFreq related editable parameters in the power.conf file
 */
typedef struct {
        char    cpu_gov[EDIT_TYPE_SIZE];
        int     cpu_th;
} pconf_edit_type;

/*
 * CPUFreq interospect XML that exports the various CPUFreq HAL interface
 * supported methods
 */
const char *cpufreq_introspect_xml = \
        "       <method name= \"SetCPUFreqGovernor\">\n \
                <arg type= \"s\" name= \"governor\" direction= \"in\"/>\n \
        </method>\n \
        <method name= \"GetCPUFreqGovernor\">\n \
                <type= \"s\" direction= \"out\"/>\n \
        </method>\n \
        <method name= \"SetCPUFreqPerformance\">\n \
                <arg type=\"i\" direction=\"in\"/>\n \
        </method>\n \
        <method name= \"GetCPUFreqPerformance\">\n \
                <type=\"i\" direction=\"out\"/>\n \
        </method>\n \
        <method name= \"GetCPUFreqAvailableGovernors\">\n \
                <type=\"s\" direction=\"out\"/>\n \
        </method>\n";

/*
 * List of governors that are currently supported
 */
char *const gov_list[] = {
        "ondemand",
        "performance",
        NULL
};

static char current_gov[EDIT_TYPE_SIZE];

/*
 * Free up the mem allocated to hold the DBusError
 */
static void
check_and_free_error(DBusError *error)
{
        if (dbus_error_is_set (error)) {
                dbus_error_free (error);
        }
}

/*
 * Edit the /etc/power.conf file to update the cpupm and cpupm_threshold values
 * Return 0 on success
 *        1 if the governor is not available or supported
 *       -1 all other errors
 * NOTE: Before modifying power.conf, it is first copied into a temp file, and
 * pmconfig is executed on the temp file with -f option, which uses temp file
 * to set the PM config and then replaces power.conf with the temp file.
 */
static int
edit_power_conf_file(pconf_edit_type pc_edit_type,
    power_conf_hal_type pc_hal_type, char *tmp_file)
{
        FILE    *pfile;
        char    tstr[FILE_ARR_SIZE];
        char    temp_str[FILE_ARR_SIZE];
        long    fset = 0;
        long    next_fset = 0;
        char    *file_edit_type;
        char    *file_edit_value;
        char    file_edit_threshold[FILE_ARR_SIZE];
        char    file_update_str[FILE_ARR_SIZE];
        int     res = 0;
        char    cp_cmd_str[128];
        int     tmp_fd;

        /*
         * Copy /etc/power.conf to temp file
         */
        if (tmp_file == NULL) {
                HAL_INFO ((" Invalid temp file name"));
                return (EINVAL);
        }
        sprintf (cp_cmd_str, "/usr/bin/cp %s %s", POWER_CONF_FILE, tmp_file);
        if (system (cp_cmd_str) != 0) {
                HAL_ERROR ((" Error in copying %s to %s, %s",
                    POWER_CONF_FILE, tmp_file, strerror (errno)));
                return (errno);
        }

        pfile = fopen (tmp_file, "r+");
        if (pfile == NULL) {
                HAL_INFO (("Cannot open file %s: %s",
                    tmp_file, strerror (errno)));
                return (errno);
        }

        switch (pc_hal_type) {
        case CPU_GOV:
                if ((pc_edit_type.cpu_gov == NULL) ||
                    ((strcmp (pc_edit_type.cpu_gov, "ondemand") != 0) &&
                    (strcmp (pc_edit_type.cpu_gov, "performance") != 0))) {
                        HAL_INFO ((" CPU governor is not available/valid."
                            " Should be either ondemand or performance"));
                        res = EINVAL;
                        goto out;
                }
                file_edit_type = "cpupm";
                if (strcmp (pc_edit_type.cpu_gov, "ondemand") == 0) {
                        file_edit_value = " enable";
                } else {
                        file_edit_value = "disable";
                }
                break;
        case CPU_PERFORMANCE:
                if (pc_edit_type.cpu_th == 0) {
                        HAL_INFO ((" CPU Threshold is not valid."));
                        res = EINVAL;
                        goto out;
                }
                file_edit_type = "cpu-threshold";
                sprintf (file_edit_threshold, "%d", pc_edit_type.cpu_th);
                file_edit_value = file_edit_threshold;
                break;
        default:
                HAL_DEBUG ((" Cannot recognize the type of change being"
                    " made to /etc/power.conf"));
                        res = EINVAL;
                        goto out;
        }

        while (fgets (tstr, FILE_ARR_SIZE, pfile) != NULL) {
                if ((tstr == NULL) || (strlen (tstr) <= 0))
                        continue;
                /*
                 * Look for line containing "cpupm" or "cpu-threshold"
                 */

                if (strstr (tstr, file_edit_type) == NULL) {
                        fset = fset + strlen (tstr);
                        continue;
                }
                /*
                 * If the required value already present. Just
                 * return
                 */
                if (strstr (tstr, file_edit_value) != NULL) {
                        res = 0;
                        goto out;
                }

                if (fseek (pfile, fset, SEEK_SET) != 0) {
                        HAL_ERROR (("\n Error in fseek %s: %s",
                            POWER_CONF_FILE, strerror (errno)));
                        res = errno;
                        goto out;
                }
                /*
                 * Update the file with new values
                 */
                sprintf (file_update_str, "%s %s \n",
                    file_edit_type, file_edit_value);

                /*
                 * Check if the currrent line is the last one. If not,
                 * to avoid overwriting and wasting space, move remaining
                 * lines upwards and update at the end
                 */
                next_fset = fset + strlen(tstr);
                if (fseek (pfile, next_fset, SEEK_SET) != 0) {
                        HAL_ERROR (("\n Error in fseek %s: %s",
                            tmp_file, strerror (errno)));
                        res = errno;
                        goto out;
                }
                if (fgets (tstr, FILE_ARR_SIZE, pfile) != NULL) {
                        do {
                                snprintf (temp_str, FILE_ARR_SIZE,
                                    "%s\n", tstr);
                                fseek (pfile, fset, SEEK_SET);
                                fputs (temp_str, pfile);
                                fset = fset + strlen(tstr);
                                next_fset = next_fset + strlen(tstr);
                                fseek (pfile, next_fset, SEEK_SET);

                        } while (fgets (tstr, FILE_ARR_SIZE, pfile) != NULL);
                }

                fseek (pfile, fset, SEEK_SET);

                if (fputs (file_update_str, pfile) == EOF) {
                        HAL_ERROR (("\n Error in writing to"
                            " %s: %s", POWER_CONF_FILE,
                            strerror (errno)));
                        res = errno;
                        goto out;
                }

                if (fflush (pfile) == EOF) {
                        HAL_ERROR (("\n Error in flushing to"
                            " %s: %s", POWER_CONF_FILE,
                            strerror (errno)));
                }
                res = 0;
                goto out;
        }

        /*
         * If the pointer comes here, then the property is not already present.
         * Have to append to the file
         */
        HAL_DEBUG (("\n Passed value not found. Will append to the file"));
        if (fseek (pfile, 0, SEEK_END) != 0) {
                HAL_ERROR (("\n Error in fseek to %s: %s",
                    POWER_CONF_FILE, strerror (errno)));
                res = errno;
                goto out;
        }

        /*
         * Update the file with new values
         */
        sprintf (file_update_str, "%s %s \n", file_edit_type, file_edit_value);

        if (fputs (file_update_str, pfile) == EOF) {
                HAL_ERROR (("Error in writing to file %s: %s",
                    POWER_CONF_FILE, strerror (errno)));
                res = errno;
                goto out;
        }

        if (fflush (pfile) == EOF) {
                HAL_ERROR (("\n Error in flushing to %s: %s",
                    POWER_CONF_FILE, strerror (errno)));
        }
        res = 0;
out:
        fclose (pfile);
        return (res);
}

/*
 * Depending on the type(cpupm or cpu-threshold) to read, check if they are
 * present. If present, return the corresponding value through pc_value arg
 * and return 1 from the function. If there is no corresponding entry,return 0.
 * Return -1 on error
 */

static int
read_power_conf_file(pconf_edit_type *pc_value,
    power_conf_hal_type pc_hal_type)
{

        FILE    *pfile;
        char    tstr[FILE_ARR_SIZE];
        long    fset = 0;
        char    *file_edit_type;
        char    *tpstr;
        int     res = 0;

        pfile = fopen (POWER_CONF_FILE, "r");
        if (pfile == NULL) {
                HAL_INFO (("\n Cannot open the file %s: %s",
                    POWER_CONF_FILE, strerror (errno)));
                return (-1);
        }

        switch (pc_hal_type) {
        case CPU_GOV:
                file_edit_type = "cpupm";
                break;
        case CPU_PERFORMANCE:
                file_edit_type = "cpu-threshold";
                break;
        default :
                HAL_DEBUG (("Cannot recognize the HAL type to get value"));
                res = -1;
                goto out;
        }

        while (fgets (tstr, FILE_ARR_SIZE, pfile) != NULL) {
                if ((tstr == NULL) || (strlen (tstr) <= 0))
                        continue;
                /*
                 * Look for line containing "cpupm" or "cpu-threshold"
                 */
                if (strstr (tstr, file_edit_type) == NULL)
                        continue;

                /*
                 * If the required value already present. Just
                 * get the value
                 */
                tpstr = strtok (tstr, " ");
                tpstr = strtok (NULL, " ");
                if (tpstr == NULL) {
                        HAL_INFO (("Value of %s in %s is not valid",
                            file_edit_type, POWER_CONF_FILE));
                        res = -1;
                        goto out;
                }

                if (pc_hal_type == CPU_GOV) {
                        /*
                         * Copy the corresponding governor
                         */
                        if (strcmp (tpstr, "enable") == 0) {
                                sprintf (pc_value->cpu_gov,
                                    "%s", "ondemand");
                        } else {
                                sprintf (pc_value->cpu_gov,
                                    "%s", "performance");
                        }
                } else {
                        pc_value->cpu_th = atoi (tpstr);
                }
                res = 1;
                goto out;
        }
        /*
         * Entry not found in the file
         */
        HAL_DEBUG ((" No entry of %s in %s", file_edit_type, POWER_CONF_FILE));
        res = 0;

out:
        fclose (pfile);
        return (res);
}


/*
 * Depending on the type(Governor or Perfromance) to read, get the current
 * values through PM ioctls().
 * For "Governor", return the cpupm state and for "Performance" return the
 * current cpu threshold.
 * Return the corresponding value through cur_value and return 1 from the
 * function for success. Return -1 on error
 */

static int
get_cur_val(pconf_edit_type *cur_value,
    power_conf_hal_type pc_hal_type)
{

        int pm_fd;
        int res = -1;
        int pm_ret;

        pm_fd = open (PM, O_RDONLY);
        if (pm_fd == -1) {
                HAL_ERROR (("Error opening %s: %s \n", PM, strerror (errno)));
                return (res);
        }

        switch (pc_hal_type) {
        case CPU_GOV:
                /*
                 * First check the PM_GET_CPUPM_STATE. If it is not available
                 * then check PM_GET_PM_STATE
                 */
                pm_ret = ioctl (pm_fd, PM_GET_CPUPM_STATE);
                if (pm_ret < 0) {
                        HAL_ERROR (("Error in ioctl PM_GET_CPUPM_STATE: %s \n",
                            strerror (errno)));
                        goto out;
                }
                switch (pm_ret) {
                case PM_CPU_PM_ENABLED:
                        sprintf (cur_value->cpu_gov, "%s", "ondemand");
                        res = 1;
                        goto out;
                case PM_CPU_PM_DISABLED:
                        sprintf (cur_value->cpu_gov, "%s", "performance");
                        res = 1;
                        goto out;
                case PM_CPU_PM_NOTSET:
                        /*
                         * Check for PM_GET_PM_STATE
                         */
                        pm_ret = ioctl (pm_fd, PM_GET_PM_STATE);
                        if (pm_ret < 0) {
                                HAL_ERROR (("Error in ioctl PM_GET_PM_STATE: "
                                    "%s", strerror (errno)));
                                goto out;
                        }
                        switch (pm_ret) {
                        case PM_SYSTEM_PM_ENABLED:
                                sprintf (cur_value->cpu_gov, "%s", "ondemand");
                                res = 1;
                                goto out;
                        case PM_SYSTEM_PM_DISABLED:
                                sprintf (cur_value->cpu_gov, "%s",
                                    "performance");
                                res = 1;
                                goto out;
                        default:
                                HAL_ERROR (("PM Internal error during ioctl "
                                    "PM_GET_PM_STATE"));
                                goto out;
                        }
                default:
                        HAL_ERROR (("Unknown value ioctl PM_GET_CPUPM_STATE"));
                        goto out;
                }
        case CPU_PERFORMANCE:
                /*
                 * First check the PM_GET_CPU_THRESHOLD. If it is not available
                 * then check PM_GET_SYSTEM_THRESHOLD
                 */
                pm_ret = ioctl (pm_fd, PM_GET_CPU_THRESHOLD);
                if (pm_ret >= 0) {
                        cur_value->cpu_th = pm_ret;
                        res = 1;
                        goto out;
                } else if ((pm_ret == EINVAL) || (pm_ret == ENOTTY)) {
                        /*
                         * PM_GET_CPU_THRESHOLD is not available
                         */
                        pm_ret = ioctl (pm_fd, PM_GET_SYSTEM_THRESHOLD);
                        if (res >= 0) {
                                cur_value->cpu_th = pm_ret;
                                res = 1;
                                goto out;
                        } else {
                                HAL_ERROR (("Error in PM_GET_CPU_THRESHOLD: %s",
                                    strerror (errno)));
                                goto out;
                        }
                } else {
                        HAL_ERROR ((" Error in ioctl PM_GET_CPU_THRESHOLD: %s",
                            strerror (errno)));
                        goto out;
                }
        default :
                HAL_DEBUG (("Cannot recognize the HAL type to get value"));
                goto out;
        }
out:
        close (pm_fd);
        return (res);
}
/*
 * Send an error message as a response to the pending call
 */
static void
generate_err_msg(DBusConnection *con,
    DBusMessage *msg,
    const char *err_name,
    char *fmt, ...)
{

        DBusMessage     *err_msg;
        char            err_buf[ERR_BUF_SIZE];
        va_list         va_args;

        va_start (va_args, fmt);
        vsnprintf (err_buf, ERR_BUF_SIZE, fmt, va_args);
        va_end (va_args);

        HAL_DEBUG ((" Sending error message: %s", err_buf));

        err_msg = dbus_message_new_error (msg, err_name, err_buf);
        if (err_msg == NULL) {
                HAL_ERROR (("No Memory for DBUS error msg"));
                return;
        }

        if (!dbus_connection_send (con, err_msg, NULL)) {
                HAL_ERROR ((" Out Of Memory!"));
        }
        dbus_connection_flush (con);

}

static void
gen_unknown_gov_err(DBusConnection *con,
    DBusMessage *msg,
    char *err_str)
{

        generate_err_msg (con,
            msg,
            "org.freedesktop.Hal.CPUFreq.UnknownGovernor",
            "Unknown CPUFreq Governor: %s",
            err_str);
}

static void
gen_no_suitable_gov_err(DBusConnection *con,
    DBusMessage *msg,
    char *err_str)
{

        generate_err_msg (con,
            msg,
            "org.freedesktop.Hal.CPUFreq.NoSuitableGovernor",
            "Could not find a suitable governor: %s",
            err_str);
}

static void
gen_cpufreq_err(DBusConnection *con,
    DBusMessage *msg,
    char *err_str)
{
        generate_err_msg (con,
            msg,
            "org.freedesktop.Hal.CPUFreq.Error",
            "%s: Syslog might give more information",
            err_str);
}


/*
 * Puts the required cpufreq audit data and calls adt_put_event()
 * to generate auditing
 */
static void
audit_cpufreq(const adt_export_data_t *imported_state, au_event_t event_id,
    int result, const char *auth_used, const int cpu_thr_value)
{
        adt_session_data_t      *ah;
        adt_event_data_t        *event;
        struct passwd           *msg_pwd;
        uid_t                   gid;

        if (adt_start_session (&ah, imported_state, 0) != 0) {
                HAL_INFO (("adt_start_session failed: %s", strerror (errno)));
                return;
        }

        if ((event = adt_alloc_event (ah, event_id)) == NULL) {
                HAL_INFO(("adt_alloc_event audit_cpufreq failed: %s",
                    strerror (errno)));
                return;
        }

        switch (event_id) {
        case ADT_cpu_ondemand:
                event->adt_cpu_ondemand.auth_used = (char *)auth_used;
                break;
        case ADT_cpu_performance:
                event->adt_cpu_performance.auth_used = (char *)auth_used;
                break;
        case ADT_cpu_threshold:
                event->adt_cpu_threshold.auth_used = (char *)auth_used;
                event->adt_cpu_threshold.threshold = cpu_thr_value;
                break;
        default:
                goto clean;
        }

        if (result == 0) {
                if (adt_put_event (event, ADT_SUCCESS, ADT_SUCCESS) != 0) {
                        HAL_INFO (("adt_put_event(%d, ADT_SUCCESS) failed",
                            event_id));
                }
        } else {
                if (adt_put_event (event, ADT_FAILURE, result) != 0) {
                        HAL_INFO (("adt_put_event(%d, ADT_FAILURE) failed",
                            event_id));
                }
        }

clean:
        adt_free_event (event);
        (void) adt_end_session (ah);
}

/*
 * Check if the cpufreq related operations are authorized
 */

static int
check_authorization(DBusConnection *con, DBusMessage *msg)
{
        int             adt_res = 0;
#ifdef HAVE_POLKIT
        char            user_id[128];
        char            *udi;
        char            *privilege;
        DBusError       error;
        gboolean        is_priv_allowed;
        gboolean        is_priv_temporary;
        DBusConnection  *system_bus = NULL;
        LibPolKitContext *pol_ctx = NULL;

        /*
         * Check for authorization before proceeding
         */
        udi = getenv ("HAL_PROP_INFO_UDI");
        privilege = "hal-power-cpu";

        dbus_error_init (&error);
        system_bus = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
        if (system_bus == NULL) {
                HAL_INFO (("Cannot connect to the system bus"));
                LIBHAL_FREE_DBUS_ERROR (&error);
                gen_cpufreq_err (con, msg, "Cannot connect to the system bus");
                adt_res = EINVAL;
                goto out;
        }

        sender = dbus_message_get_sender (msg);
        HAL_INFO (("Auth Sender: %s", sender));

        if (sender == NULL) {
                HAL_INFO (("Could not get the sender of the message"));
                gen_cpufreq_err (con, msg,
                    "Could not get the sender of the message");
                adt_res = ADT_FAIL_VALUE_AUTH;
                goto out;
        }

        dbus_error_init (&error);
        uid = dbus_bus_get_unix_user (system_bus, sender, &error);
        if (dbus_error_is_set (&error)) {
                HAL_INFO (("Could not get the user id of the message"));
                LIBHAL_FREE_DBUS_ERROR (&error);
                gen_cpufreq_err (con, msg,
                    "Could not get the user id of the message sender");
                adt_res = ADT_FAIL_VALUE_AUTH;
                goto out;
        }

        snprintf (user_id, sizeof (user_id), "%d", uid);
        HAL_DEBUG ((" User id is : %d", uid));

        pol_ctx = libpolkit_new_context (system_bus);
        if (pol_ctx == NULL) {
                HAL_INFO (("Cannot get libpolkit context"));
                gen_cpufreq_err (con, msg,
                    "Cannot get libpolkit context to check privileges");
                adt_res = ADT_FAIL_VALUE_AUTH;
                goto out;
        }

        if (libpolkit_is_uid_allowed_for_privilege (pol_ctx,
            NULL,
            user_id,
            privilege,
            udi,
            &is_priv_allowed,
            &is_priv_temporary,
            NULL) != LIBPOLKIT_RESULT_OK) {
                HAL_INFO (("Cannot lookup privilege from PolicyKit"));
                gen_cpufreq_err (con, msg,
                    "Error looking up privileges from Policykit");
                adt_res = ADT_FAIL_VALUE_AUTH;
                goto out;
        }

        if (!is_priv_allowed) {
                HAL_INFO (("Caller doesn't possess required privilege to"
                    " change the governor"));
                gen_cpufreq_err (con, msg,
                    "Caller doesn't possess required "
                    "privilege to change the governor");
                adt_res = ADT_FAIL_VALUE_AUTH;
                goto out;
        }

        HAL_DEBUG ((" Privilege Succeed"));

#endif
out:
        return (adt_res);
}

/*
 * Sets the CPU Freq governor. It sets the gov name in the /etc/power.conf
 * and executes pmconfig. If governor is "ondemand" then "cpupm" is enabled in
 * and if governor is performance, then "cpupm" is disabled
 */
static void
set_cpufreq_gov(DBusConnection *con, DBusMessage *msg, void *udata)
{
        DBusMessageIter arg_iter;
        DBusMessage     *msg_reply;
        char            *arg_val;
        int             arg_type;
        int             pid;
        int             done_flag = 0;
        int             sleep_time = 0;
        int             status;
        int             adt_res = 0;
        char            tmp_conf_file[64] = "/tmp/power.conf.XXXXXX";
        int             tmp_fd;
        char            pmconfig_cmd[128];
        pconf_edit_type pc_edit_type;
#ifdef sun
        adt_export_data_t *adt_data;
        size_t          adt_data_size;
        DBusConnection  *system_bus = NULL;
        DBusError       error;
#endif

        if (! dbus_message_iter_init (msg, &arg_iter)) {
                HAL_DEBUG (("Incoming message has no arguments"));
                gen_unknown_gov_err (con, msg, "No governor specified");
                adt_res = EINVAL;
                goto out;
        }
        arg_type = dbus_message_iter_get_arg_type (&arg_iter);

        if (arg_type != DBUS_TYPE_STRING) {
                HAL_DEBUG (("Incomming message arg type is not string"));
                gen_unknown_gov_err (con, msg,
                    "Specified governor is not a string");
                adt_res = EINVAL;
                goto out;
        }
        dbus_message_iter_get_basic (&arg_iter, &arg_val);
        if (arg_val != NULL) {
                HAL_DEBUG (("SetCPUFreqGov is: %s", arg_val));
        } else {
                HAL_DEBUG (("Could not get SetCPUFreqGov from message iter"));
                adt_res = EINVAL;
                goto out;
        }

        adt_res = check_authorization (con, msg);

        if (adt_res != 0) {
                goto out;
        }

        /*
         * Update the /etc/power.conf file.
         */
        tmp_fd = mkstemp (tmp_conf_file);
        if (tmp_fd == -1) {
                HAL_ERROR ((" Error in creating a temp conf file"));
                adt_res = EINVAL;
                goto out;
        }
        strcpy (pc_edit_type.cpu_gov, arg_val);
        adt_res = edit_power_conf_file (pc_edit_type, CPU_GOV, tmp_conf_file);
        if (adt_res != 0) {
                HAL_DEBUG (("Error in edit /etc/power.conf"));
                gen_cpufreq_err (con, msg,
                    "Internal Error while setting the governor");
                unlink (tmp_conf_file);
                goto out;
        }

        /*
         * Execute pmconfig
         */
        sprintf (pmconfig_cmd, "%s %s", PMCONFIG, tmp_conf_file);
        if (system (pmconfig_cmd) != 0) {
                HAL_ERROR ((" Error in executing pmconfig: %s",
                    strerror (errno)));
                adt_res = errno;
                gen_cpufreq_err (con, msg, "Error in executing pmconfig");
                unlink (tmp_conf_file);
                goto out;
        }
        unlink (tmp_conf_file);
        HAL_DEBUG (("Executed pmconfig"));
        sprintf (current_gov, "%s", arg_val);

        /*
         * Just return an empty response, so that if the client
         * is waiting for any response will not keep waiting
         */
        msg_reply = dbus_message_new_method_return (msg);
        if (msg_reply == NULL) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg,
                    "Out of memory to create a response");
                adt_res = ENOMEM;
                goto out;
        }

        if (!dbus_connection_send (con, msg_reply, NULL)) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg,
                    "Out of memory to create a response");
                adt_res = ENOMEM;
                goto out;
        }

        dbus_connection_flush (con);

out:

#ifdef sun
        /*
         * Audit the new governor change
         */
        dbus_error_init (&error);
        system_bus = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
        if (system_bus == NULL) {
                HAL_INFO (("Cannot connect to the system bus %s",
                    error.message));
                LIBHAL_FREE_DBUS_ERROR (&error);
                return;
        }

        adt_data = get_audit_export_data (system_bus, sender, &adt_data_size);
        if (adt_data != NULL) {
                if (strcmp (arg_val, "ondemand") == 0) {
                        audit_cpufreq (adt_data, ADT_cpu_ondemand, adt_res,
                            "solaris.system.power.cpu", 0);
                } else if (strcmp (arg_val, "performance") == 0) {
                        audit_cpufreq (adt_data, ADT_cpu_performance, adt_res,
                            "solaris.system.power.cpu", 0);
                }
                free (adt_data);
        } else {
                HAL_INFO ((" Could not get audit export data"));
        }
#endif /* sun */
}

/*
 * Sets the CPU Freq performance. It sets the cpu-threshold in the
 * /etc/power.conf and executes pmconfig. The performnace value should
 * be between 1 to 100. The cpu-threshold = ((performance val) * 15) secs.
 */
static void
set_cpufreq_performance(DBusConnection *con, DBusMessage *msg, void *udata)
{

        DBusMessageIter arg_iter;
        DBusMessage     *msg_reply;
        int             arg_val;
        int             arg_type;
        int             pid;
        int             done_flag = 0;
        int             sleep_time = 0;
        int             adt_res = 0;
        char            tmp_conf_file[64] = "/tmp/power.conf.XXXXXX";
        int             tmp_fd;
        char            pmconfig_cmd[128];
        pconf_edit_type pc_edit_type;
#ifdef sun
        adt_export_data_t *adt_data;
        size_t          adt_data_size;
        DBusConnection  *system_bus = NULL;
        DBusError       error;
#endif

        adt_res = check_authorization (con, msg);

        if (adt_res != 0) {
                goto out;
        }

        /*
         * Performance can only be set to dynamic governors. Currently the
         * only supported dynamic governor is ondemand.
         */
        if (current_gov[0] == 0) {
                /*
                 * Read the current governor from /etc/power.conf
                 */
                if (read_power_conf_file (&pc_edit_type, CPU_GOV) != 1) {
                        HAL_ERROR ((" Error in reading from /etc/power.conf"));
                        gen_cpufreq_err (con, msg, "Internal error while "
                            "getting the governor");
                        adt_res = EINVAL;
                        goto out;
                }
                sprintf (current_gov, "%s", pc_edit_type.cpu_gov);
        }

        if (strcmp (current_gov, "ondemand") != 0) {
                HAL_DEBUG (("To set performance the current gov should be "
                    "dynamic like ondemand"));
                gen_no_suitable_gov_err (con, msg, "Cannot set performance "
                    "to the current governor");
                adt_res = EINVAL;
                goto out;
        }

        if (! dbus_message_iter_init (msg, &arg_iter)) {
                HAL_DEBUG (("Incoming message has no arguments"));
                gen_no_suitable_gov_err(con, msg, "No performance specified");
                adt_res = EINVAL;
                goto out;
        }
        arg_type = dbus_message_iter_get_arg_type (&arg_iter);

        if (arg_type != DBUS_TYPE_INT32) {
                HAL_DEBUG (("Incomming message arg type is not Integer"));
                gen_no_suitable_gov_err (con, msg,
                    "Specified performance is not a Integer");
                adt_res = EINVAL;
                goto out;
        }
        dbus_message_iter_get_basic (&arg_iter, &arg_val);
        if ((arg_val < 1) || (arg_val > 100)) {
                HAL_INFO (("SetCPUFreqPerformance should be between 1 to 100"
                    ": %d", arg_val));
                gen_no_suitable_gov_err (con, msg,
                    "Performance value should be between 1 and 100");
                adt_res = EINVAL;
                goto out;
        }

        HAL_DEBUG (("SetCPUFreqPerformance is: %d", arg_val));

        /*
         * Update the /etc/power.conf file
         */
        tmp_fd = mkstemp (tmp_conf_file);
        if (tmp_fd == -1) {
                HAL_ERROR ((" Error in creating a temp conf file"));
                adt_res = EINVAL;
                goto out;
        }
        pc_edit_type.cpu_th = arg_val * 15;
        adt_res = edit_power_conf_file (pc_edit_type, CPU_PERFORMANCE,
            tmp_conf_file);
        if (adt_res != 0) {
                HAL_DEBUG (("Error while editing /etc/power.conf"));
                gen_cpufreq_err (con, msg,
                    "Internal error while setting the performance");
                unlink (tmp_conf_file);
                goto out;
        }

        /*
         * Execute pmconfig
         */
        sprintf (pmconfig_cmd, "%s %s", PMCONFIG, tmp_conf_file);
        if (system (pmconfig_cmd) != 0) {
                HAL_ERROR ((" Error in executing pmconfig: %s",
                    strerror (errno)));
                adt_res = errno;
                gen_cpufreq_err (con, msg,
                    "Internal error while setting the performance");
                unlink (tmp_conf_file);
                goto out;
        }
        unlink (tmp_conf_file);
        HAL_DEBUG (("Executed pmconfig"));

        /*
         * Just return an empty response, so that if the client
         * is waiting for any response will not keep waiting
         */

        msg_reply = dbus_message_new_method_return (msg);
        if (msg_reply == NULL) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg,
                    "Out of memory to create a response");
                adt_res = ENOMEM;
                goto out;
        }

        if (!dbus_connection_send (con, msg_reply, NULL)) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg,
                    "Out of memory to create a response");
                adt_res = ENOMEM;
                goto out;
        }

        dbus_connection_flush (con);
out:
#ifdef sun

        /*
         * Audit the new performance change
         */
        dbus_error_init (&error);
        system_bus = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
        if (system_bus == NULL) {
                HAL_INFO (("Cannot connect to the system bus %s",
                    error.message));
                LIBHAL_FREE_DBUS_ERROR (&error);
                return;
        }

        adt_data = get_audit_export_data (system_bus, sender, &adt_data_size);
        if (adt_data != NULL) {
                audit_cpufreq (adt_data, ADT_cpu_threshold, adt_res,
                    "solaris.system.power.cpu", arg_val);
                free (adt_data);
        } else {
                HAL_INFO ((" Could not get audit export data"));
        }

#endif /* sun */
}

/*
 * Returns in the dbus message the current gov.
 */
static void
get_cpufreq_gov(DBusConnection *con, DBusMessage *msg, void *udata)
{

        DBusMessageIter rep_iter;
        DBusMessage     *msg_reply;
        int             res;
        pconf_edit_type pc_type;
        char            *param;

        /*
         * Get the governor type from /etc/power.conf if it is present.
         */
        res = get_cur_val (&pc_type, CPU_GOV);
        if (res != 1) {
                HAL_INFO ((" Error in getting the current governor"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the governor");
                return;
        }

        HAL_DEBUG ((" Current governor is: %s", pc_type.cpu_gov));

        msg_reply = dbus_message_new_method_return (msg);
        if (msg_reply == NULL) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg,
                    "Internal error while getting the governor");
                return;
        }

        /*
         * Append reply arguments
         */
        param = (char *) malloc (sizeof (char) * 250);
        if (param == NULL) {
                HAL_ERROR (("\n Could not allocate mem to param"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the governor");
                return;
        }
        sprintf (param, "%s",  pc_type.cpu_gov);

        dbus_message_iter_init_append (msg_reply, &rep_iter);
        if (!dbus_message_iter_append_basic (&rep_iter, DBUS_TYPE_STRING,
            &param)) {
                HAL_ERROR (("\n Out Of Memory!\n"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the governor");
                free (param);
                return;
        }

        if (!dbus_connection_send (con, msg_reply, NULL)) {
                HAL_ERROR (("\n Out Of Memory!\n"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the governor");
                free (param);
                return;
        }
        dbus_connection_flush (con);
        free (param);
}

/*
 * Returns in the dbus message the current performance value
 */
static void
get_cpufreq_performance(DBusConnection *con, DBusMessage *msg, void *udata)
{

        DBusMessageIter rep_iter;
        DBusMessage     *msg_reply;
        int             res;
        pconf_edit_type pc_type;
        int             param_int;

        /*
         * Get the performance value
         */
        res = get_cur_val (&pc_type, CPU_PERFORMANCE);
        if (res != 1) {
                HAL_INFO ((" Error in getting current performance"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the performance value");
                return;
        }

        HAL_DEBUG ((" The current performance: %d", pc_type.cpu_th));

        msg_reply = dbus_message_new_method_return (msg);
        if (msg_reply == NULL) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the performance value");
                return;
        }

        /*
         * Append reply arguments.pc_type.cpu_th gives the current cputhreshold
         * vlaue in seconds. Have to convert it into CPU HAL interface
         * performance value
         */
        if (pc_type.cpu_th < 15)
                param_int = 1;
        else
                param_int = (pc_type.cpu_th / 15);

        HAL_DEBUG (("Performance: %d \n", param_int));

        dbus_message_iter_init_append (msg_reply, &rep_iter);
        if (!dbus_message_iter_append_basic (&rep_iter, DBUS_TYPE_INT32,
            &param_int)) {
                HAL_ERROR (("\n Out Of Memory!\n"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the performance value");
                return;
        }

        if (!dbus_connection_send (con, msg_reply, NULL)) {
                HAL_ERROR (("\n Out Of Memory!\n"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the performance value");
                return;
        }
        dbus_connection_flush (con);
}

/*
 * Returns list of available governors. Currently just two governors are
 * supported. They are "ondemand" and "performance"
 */

static void
get_cpufreq_avail_gov(DBusConnection *con, DBusMessage *msg, void *udata)
{

        DBusMessageIter rep_iter;
        DBusMessageIter array_iter;
        DBusMessage     *msg_reply;
        int             ngov;

        msg_reply = dbus_message_new_method_return (msg);
        if (msg_reply == NULL) {
                HAL_ERROR (("Out of memory to msg reply"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the list of governors");
                return;
        }

        /*
         * Append reply arguments
         */
        dbus_message_iter_init_append (msg_reply, &rep_iter);

        if (!dbus_message_iter_open_container (&rep_iter,
            DBUS_TYPE_ARRAY,
            DBUS_TYPE_STRING_AS_STRING,
            &array_iter)) {
                HAL_ERROR (("\n Out of memory to msg reply array"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the list of governors");
                return;
        }

        for (ngov = 0; gov_list[ngov] != NULL; ngov++) {
                HAL_DEBUG (("\n%d Gov Name: %s", ngov, gov_list[ngov]));
                dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING,
                    &gov_list[ngov]);
        }
        dbus_message_iter_close_container (&rep_iter, &array_iter);

        if (!dbus_connection_send (con, msg_reply, NULL)) {
                HAL_ERROR (("\n Out Of Memory!\n"));
                gen_cpufreq_err (con, msg, "Internal error while getting"
                    " the list of governors");
                return;
        }
        dbus_connection_flush (con);
}

static DBusHandlerResult
hald_dbus_cpufreq_filter(DBusConnection *con, DBusMessage *msg, void *udata)
{
        HAL_DEBUG ((" Inside CPUFreq filter:%s", dbus_message_get_path(msg)));
        /*
         * Check for method types
         */
        if (!dbus_connection_get_is_connected (con))
                HAL_DEBUG (("Connection disconnected in cpufreq addon"));

        if (dbus_message_is_method_call (msg,
            "org.freedesktop.Hal.Device.CPUFreq",
            "SetCPUFreqGovernor")) {
                HAL_DEBUG (("---- SetCPUFreqGovernor is called "));

                set_cpufreq_gov (con, msg, udata);

        } else if (dbus_message_is_method_call (msg,
            "org.freedesktop.Hal.Device.CPUFreq",
            "GetCPUFreqGovernor")) {
                HAL_DEBUG (("---- GetCPUFreqGovernor is called "));

                get_cpufreq_gov (con, msg, udata);
        } else if (dbus_message_is_method_call (msg,
            "org.freedesktop.Hal.Device.CPUFreq",
            "GetCPUFreqAvailableGovernors")) {
                HAL_DEBUG (("---- GetCPUFreqAvailableGovernors is called "));

                get_cpufreq_avail_gov (con, msg, udata);
        } else if (dbus_message_is_method_call (msg,
            "org.freedesktop.Hal.Device.CPUFreq",
            "SetCPUFreqPerformance")) {
                HAL_DEBUG (("---- SetCPUFreqPerformance is called "));

                set_cpufreq_performance (con, msg, udata);
        } else if (dbus_message_is_method_call (msg,
            "org.freedesktop.Hal.Device.CPUFreq",
            "GetCPUFreqPerformance")) {
                HAL_DEBUG (("---- GetCPUFreqPerformance is called "));

                get_cpufreq_performance (con, msg, udata);
        } else {
                HAL_DEBUG (("---Not Set/Get cpufreq gov---"));
        }

        return (DBUS_HANDLER_RESULT_HANDLED);

}

static void
drop_privileges()
{
        priv_set_t *pPrivSet = NULL;
        priv_set_t *lPrivSet = NULL;

        /*
         * Start with the 'basic' privilege set and then add any
         * of the privileges that will be required.
         */
        if ((pPrivSet = priv_str_to_set ("basic", ",", NULL)) == NULL) {
                HAL_INFO (("Error in setting the priv"));
                return;
        }

        (void) priv_addset (pPrivSet, PRIV_SYS_DEVICES);

        if (setppriv (PRIV_SET, PRIV_INHERITABLE, pPrivSet) != 0) {
                HAL_INFO (("Could not set the privileges"));
                priv_freeset (pPrivSet);
                return;
        }

        (void) priv_addset (pPrivSet, PRIV_PROC_AUDIT);
        (void) priv_addset (pPrivSet, PRIV_SYS_CONFIG);

        if (setppriv (PRIV_SET, PRIV_PERMITTED, pPrivSet) != 0) {
                HAL_INFO (("Could not set the privileges"));
                priv_freeset (pPrivSet);
                return;
        }

        priv_freeset (pPrivSet);

}

int
main(int argc, char **argv)
{

        LibHalContext *ctx = NULL;
        char *udi;
        DBusError error;
        DBusConnection *conn;

        GMainLoop *loop = g_main_loop_new (NULL, FALSE);

        drop_privileges ();
        openlog ("hald-addon-cpufreq", LOG_PID, LOG_DAEMON);
        setup_logger ();

        bzero (current_gov, EDIT_TYPE_SIZE-1);

        if ((udi = getenv ("UDI")) == NULL) {
                HAL_INFO (("\n Could not get the UDI in addon-cpufreq"));
                return (0);
        }

        dbus_error_init (&error);
        if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
                HAL_ERROR (("main(): init_direct failed\n"));
                return (0);
        }
        dbus_error_init (&error);
        if (!libhal_device_addon_is_ready (ctx, getenv ("UDI"), &error)) {
                check_and_free_error (&error);
                return (0);
        }

        /*
         * Claim the cpufreq interface
         */

        HAL_DEBUG (("cpufreq Introspect XML: %s", cpufreq_introspect_xml));

        if (!libhal_device_claim_interface (ctx,
            udi,
            "org.freedesktop.Hal.Device.CPUFreq",
            cpufreq_introspect_xml,
            &error)) {
                HAL_DEBUG ((" Cannot claim the CPUFreq interface"));
                check_and_free_error (&error);
                return (0);
        }

        conn = libhal_ctx_get_dbus_connection (ctx);

        /*
         * Add the cpufreq capability
         */
        if (!libhal_device_add_capability (ctx,
            udi,
            "cpufreq_control",
            &error)) {
                HAL_DEBUG ((" Could not add cpufreq_control capability"));
                check_and_free_error (&error);
                return (0);
        }
        /*
         * Watches and times incoming messages
         */

        dbus_connection_setup_with_g_main (conn, NULL);

        /*
         * Add a filter function which gets called when a message comes in
         * and processes the message
         */

        if (!dbus_connection_add_filter (conn,
            hald_dbus_cpufreq_filter,
            NULL,
            NULL)) {
                HAL_INFO ((" Cannot add the CPUFreq filter function"));
                return (0);
        }

        dbus_connection_set_exit_on_disconnect (conn, 0);

        g_main_loop_run (loop);
}