/*
 * swrun_darwin.c:
 *     hrSWRunTable data access:
 *     Darwin
 */
/*
 * Copyright (C) 2007 Apple, Inc. All rights reserved.
 * Use is subject to license terms specified in the COPYING file
 * distributed with the Net-SNMP package.
 */
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/library/container.h>
#include <net-snmp/library/snmp_debug.h>
#include <net-snmp/data_access/swrun.h>
#include "swrun_private.h"

#include <stdlib.h>
#include <unistd.h>

#include <libproc.h>
#include <sys/proc_info.h>
#include <sys/sysctl.h>	/* for sysctl() and struct kinfo_proc */

#define __APPLE_API_EVOLVING 1
#include <sys/acl.h> /* or else CoreFoundation.h barfs */
#undef __APPLE_API_EVOLVING 

#include <CoreFoundation/CFBase.h>
#include <CoreFoundation/CFNumber.h>
#include <CoreFoundation/CFBundle.h>
#include <CoreServices/CoreServices.h>
#include <IOKit/IOCFBundle.h>
#include <mach/mach.h>
#include <mach/mach_time.h>

/** sigh... can't find Processes.h */
#ifndef kProcessDictionaryIncludeAllInformationMask 
#define kProcessDictionaryIncludeAllInformationMask (long)0xFFFFFFFF
#endif
#ifndef procNotFound
#define procNotFound -600
#endif

/* ---------------------------------------------------------------------
 */
static int _kern_argmax;
static int _set_command_name(netsnmp_swrun_entry *entry);

/** avoid kernel bug in 10.2. 8192 oughta be enough anyways, right? */
#define MAX_KERN_ARGMAX 8192

/* ---------------------------------------------------------------------
 */
void
netsnmp_arch_swrun_init(void)
{
    int    mib[2] = { CTL_KERN, KERN_ARGMAX };
    size_t size, mib_size = sizeof(mib)/sizeof(mib[0]);
    
    DEBUGMSGTL(("swrun:load:arch","init\n"));

    size = sizeof(_kern_argmax);
    if (sysctl(mib, mib_size, &_kern_argmax, &size, NULL, 0) == -1) {
        snmp_log(LOG_ERR, "Error in ARGMAX sysctl(): %s", strerror(errno));
        _kern_argmax = MAX_KERN_ARGMAX;
    }
    else if (_kern_argmax > MAX_KERN_ARGMAX) {
        DEBUGMSGTL(("swrun:load:arch",
                    "artificially limiting ARGMAX to %d (from %d)\n",
                    MAX_KERN_ARGMAX, _kern_argmax));
        _kern_argmax = MAX_KERN_ARGMAX;
    }


}

/* ---------------------------------------------------------------------
 */
#define SWRUNINDENT "           "
int
netsnmp_arch_swrun_container_load( netsnmp_container *container, u_int flags)
{
    int	                 mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
    size_t               buf_size, mib_size = sizeof(mib)/sizeof(mib[0]);
    struct kinfo_proc   *processes = NULL;
    struct proc_taskallinfo taskinfo;
    netsnmp_swrun_entry *entry;
    int                  rc, num_entries, i;

    DEBUGMSGTL(("swrun:load:arch"," load\n"));

    /*
     * get size to allocate. This introduces a bit of a race condition,
     * as the size could change between this call and the next...
     */
    rc = sysctl(mib, mib_size, NULL, &buf_size, NULL, 0);
    if (rc < 0) {
        snmp_log(LOG_ERR, "KERN_PROC_ALL size sysctl failed: %d\n", rc);
        return -1;
    }

    processes = (struct kinfo_proc*) malloc(buf_size);
    if (NULL == processes) {
        snmp_log(LOG_ERR, "malloc failed\n");
        return -1;
    }

    rc = sysctl(mib, mib_size, processes, &buf_size, NULL, 0);
    if (rc < 0) {
        snmp_log(LOG_ERR, "KERN_PROC_ALL sysctl failed: %d\n", rc);
        free(processes);
        return -1;
    }
    
    num_entries = buf_size / sizeof(struct kinfo_proc);
    
    for (i = 0; i < num_entries; i++) {
        /*
         * skip empty names.
         * p_stat = (SIDL|SRUN|SSLEEP|SSTOP|SZOMB)
         */
        if (('\0' == processes[i].kp_proc.p_comm[0]) ||
            (0 == processes[i].kp_proc.p_pid)) {
            DEBUGMSGTL(("swrun:load:arch",
                        " skipping p_comm '%s', pid %5d, p_pstat %d\n",
                        processes[i].kp_proc.p_comm,
                        processes[i].kp_proc.p_pid,
                        processes[i].kp_proc.p_stat));
            continue;
        }

        DEBUGMSGTL(("swrun:load:arch"," %s pid %5d\n",
                    processes[i].kp_proc.p_comm,
                    processes[i].kp_proc.p_pid));

        entry = netsnmp_swrun_entry_create(processes[i].kp_proc.p_pid);
        if (NULL == entry)
            continue; /* error already logged by function */
        rc = CONTAINER_INSERT(container, entry);

        /*
         * p_comm is a partial name, but it is all we have at this point.
         */
        entry->hrSWRunName_len = snprintf(entry->hrSWRunName,
                                          sizeof(entry->hrSWRunName)-1,
                                          "%s", processes[i].kp_proc.p_comm);

        /** sysctl for name, path, params */
        rc = _set_command_name(entry);

        /*
         * map p_stat to RunStatus. Odd that there is no 'running' status.
         */
        switch(processes[i].kp_proc.p_stat) {
            case SRUN:
                entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNABLE;
                break;
            case SSLEEP:
            case SSTOP:
                entry->hrSWRunStatus = HRSWRUNSTATUS_NOTRUNNABLE;
                break;
            case SIDL:
            case SZOMB:
            default:
                entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;
                break;
        } 

        /*
         * check for system processes
         */
        if (P_SYSTEM & processes[i].kp_proc.p_flag) {
            entry->hrSWRunType = HRSWRUNTYPE_OPERATINGSYSTEM;
            DEBUGMSGTL(("swrun:load:arch", SWRUNINDENT "SYSTEM\n"));
        }
        else entry->hrSWRunType = HRSWRUNTYPE_APPLICATION;

        /*
         * get mem size, run time
         */
        rc = proc_pidinfo( processes[i].kp_proc.p_pid, PROC_PIDTASKALLINFO, 0,
                           &taskinfo, sizeof(taskinfo));
        if (sizeof(taskinfo) != rc) {
            DEBUGMSGTL(("swrun:load:arch", " proc_pidinfo returned %d\n", rc));
        }
        else {
            uint64_t task_mem = taskinfo.ptinfo.pti_resident_size / 1024;
            union {
                u_quad_t     uq; /* u_int64_t */
                UnsignedWide uw; /* struct u_int32_t hi/lo */
            } at, ns;
            at.uq = taskinfo.ptinfo.pti_total_user +
                    taskinfo.ptinfo.pti_total_system;
            ns = at;
            ns.uq = ns.uq / 10000000LL; /* nano to deci */
            if (task_mem > INT32_MAX) {
                DEBUGMSGTL(("swrun:load:arch", SWRUNINDENT "mem overflow\n"));
                task_mem = INT32_MAX;
            }
            if (ns.uq > INT32_MAX) {
                DEBUGMSGTL(("swrun:load:arch", SWRUNINDENT "time overflow\n"));
                ns.uq = INT32_MAX;
            }
            entry->hrSWRunPerfMem = task_mem;
            entry->hrSWRunPerfCPU = ns.uq;
        }
    }
    free(processes);

    DEBUGMSGTL(("swrun:load:arch"," loaded %d entries\n",
                (int)CONTAINER_SIZE(container)));

    return 0;
}

/* ---------------------------------------------------------------------
 * The following code was snagged from Darwin code, and the original
 * file had the following licenses:
 */

/*
 * Copyright (c) 2002-2004 Apple Computer, Inc.  All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#ifdef JAGUAR /* xxx configure test? */
static int
_set_command_name_jaguar(netsnmp_swrun_entry *entry)
{
    int	        mib[3] = {CTL_KERN, KERN_PROCARGS, 0};
    size_t      procargssize, mib_size = sizeof(mib)/sizeof(mib[0]);
    char       *arg_end, *exec_path;
    int        *ip;
    int         len;
    char       *command_beg, *command;
    char        arg_buf[MAX_KERN_ARGMAX]; /* max to avoid kernel bug */

    DEBUGMSGTL(("swrun:load:arch:_cn"," pid %d\n", entry->hrSWRunIndex));

    mib[2] = entry->hrSWRunIndex;

    memset(arg_buf, 0x0, sizeof(arg_buf));
    procargssize = _kern_argmax;
    if (sysctl(mib, mib_size, arg_buf, &procargssize, NULL, 0) == -1) {
        snmp_log(LOG_ERR, "Error in PROCARGS sysctl() for %s: %s\n",
                 entry->hrSWRunName, strerror(errno));
        entry->hrSWRunPath_len = 0;
        return -1;
    }

    /* Set ip just above the end of arg_buf. */
    arg_end = &arg_buf[procargssize];
    ip = (int *)arg_end;
    
    /*
     * Skip the last 2 words, since the last is a 0 word, and
     * the second to last may be as well, if there are no
     * arguments.
     */
    ip -= 3;
    
    /* Iterate down the arguments until a 0 word is found. */
    for (; *ip != 0; ip--) {
        if (ip == (int *)arg_buf) {
            DEBUGMSGTL(("swrun:load:arch:_cn"," unexpected toparg\n"));
            return -1;
        }
    }
    
    /* The saved exec_path is just above the 0 word. */
    ip++;
    exec_path = (char *)ip;
    DEBUGMSGTL(("swrun:load:arch:_cn"," exec_path %s\n", exec_path));
    len = strlen(exec_path);
    strlcpy(entry->hrSWRunPath, exec_path, sizeof(entry->hrSWRunPath));
    if (len > sizeof(entry->hrSWRunPath)-1) {
        DEBUGMSGTL(("swrun:load:arch:_cn"," truncating long run path\n"));
        entry->hrSWRunPath[sizeof(entry->hrSWRunPath)-2] = '$';
        entry->hrSWRunPath_len = sizeof(entry->hrSWRunPath)-1;
        DEBUGMSGTL(("swrun:load:arch:_cn"," exec_path %s\n",
                    entry->hrSWRunPath));
    }
    else
        entry->hrSWRunPath_len = len;
    
    /*
     * Get the beginning of the first argument.  It is word-aligned,
     * so skip padding '\0' bytes.
     */
    command_beg = exec_path + strlen(exec_path);
    DEBUGMSGTL(("swrun:load:arch:_cn"," command_beg '%s'\n", command_beg));
    for (; *command_beg == '\0'; command_beg++) {
        if (command_beg >= arg_end)
            return -1;
    }
    DEBUGMSGTL(("swrun:load:arch:_cn"," command_beg '%s'\n", command_beg));
    
    /* Get the basename of command. */
    command = command_beg + strlen(command_beg) + 1;
    for (command--; command >= command_beg; command--) {
        if (*command == '/')
            break;
    }
    command++;
    DEBUGMSGTL(("swrun:load:arch:_cn"," command '%s'\n", command));
    
    /* Allocate space for the command and copy. */
    DEBUGMSGTL(("swrun:load:arch:_cn",
                SWRUNINDENT "kernel name %s\n", command));
    if (strncmp(command, entry->hrSWRunName, sizeof(entry->hrSWRunName)-1)) {
        strlcpy(entry->hrSWRunName, command, sizeof(entry->hrSWRunName));
        entry->hrSWRunName_len = strlen(entry->hrSWRunName);
        DEBUGMSGTL(("swrun:load:arch:_cn", "**"
                    SWRUNINDENT "updated name to %s\n", entry->hrSWRunName));
        return 0;
    }

    /** no error, no change */
    return 1;
}
#else
static int
_set_command_name(netsnmp_swrun_entry *entry)
{
    int	        mib[3] = {CTL_KERN, 0, 0};
    size_t      procargssize, mib_size = sizeof(mib)/sizeof(mib[0]);
    char       *cp;
    int         len, nargs;
    char       *command_beg, *command, *exec_path, *argN;
    char        arg_buf[MAX_KERN_ARGMAX]; /* max to avoid kernel bug */

    /*
     * arguments
     */
    mib[1] = KERN_PROCARGS2;
    mib[2] = entry->hrSWRunIndex;

    memset(arg_buf, 0x0, sizeof(arg_buf));
    procargssize = _kern_argmax;
    if (sysctl(mib, mib_size, arg_buf, &procargssize, NULL, 0) == -1) {
        snmp_log(LOG_ERR, "Error in PROCARGS2 sysctl() for %s: %s\n",
                 entry->hrSWRunName, strerror(errno));
        entry->hrSWRunPath_len = 0;
        entry->hrSWRunParameters_len = 0;
        return -1;
    }
    else {
        memcpy(&nargs,arg_buf, sizeof(nargs));
    }

    exec_path = arg_buf + sizeof(nargs);
    len = strlen(exec_path);
    strlcpy(entry->hrSWRunPath, exec_path, sizeof(entry->hrSWRunPath));
    if (len > sizeof(entry->hrSWRunPath)-1) {
        DEBUGMSGTL(("swrun:load:arch:_cn"," truncating long run path\n"));
        entry->hrSWRunPath[sizeof(entry->hrSWRunPath)-2] = '$';
        entry->hrSWRunPath_len = sizeof(entry->hrSWRunPath)-1;
    }
    else
        entry->hrSWRunPath_len = len;

    /** Skip the saved exec_path. */
#if 0
    cp = exec_path + len;
#else
    for (cp = exec_path; cp < &arg_buf[procargssize]; cp++) {
        if (*cp == '\0') 
            break; /* End of exec_path reached. */
    }
    if (cp != exec_path + len) {
        DEBUGMSGTL(("swrun:load:arch:_cn", " OFF BY %d\n",
                    (int)((exec_path + len) - cp)));
        netsnmp_assert( cp == exec_path + len );
    }
#endif
    if (cp == &arg_buf[procargssize]) {
        DEBUGMSGTL(("swrun:load:arch:_cn"," unexpected end of buffer\n"));
        return -1;
    }

    /** Skip trailing '\0' characters. */
    for (; cp < &arg_buf[procargssize]; cp++) {
        if (*cp != '\0')
            break; /* Beginning of first argument reached. */
    }
    if (cp == &arg_buf[procargssize]) {
        DEBUGMSGTL(("swrun:load:arch:_cn"," unexpected end of buffer\n"));
        return -1;
    }
    command_beg = cp;

    /*
     * Make sure that the command is '\0'-terminated.  This protects
     * against malicious programs; under normal operation this never
     * ends up being a problem..
     */
    for (; cp < &arg_buf[procargssize]; cp++) {
        if (*cp == '\0')
            break; /* End of first argument reached. */
    }
    if (cp == &arg_buf[procargssize]) {
        DEBUGMSGTL(("swrun:load:arch:_cn"," unexpected end of buffer\n"));
        return -1;
    }
    command = cp;
    --nargs;

    /*
     * save arguments
     */
    while( nargs && cp < &arg_buf[procargssize] ) {
        /** Skip trailing '\0' characters from prev arg. */
        for (; (cp < &arg_buf[procargssize]) && (*cp == 0); cp++) 
            ; /* noop */
        if (cp == &arg_buf[procargssize])
            continue; /* effectively a break */
    
        /** save argN start */
        argN = cp;
        --nargs;
        if (0 == nargs)
            continue; /* effectively a break */

        /** Skip to end of arg */
        for (; (cp < &arg_buf[procargssize]) && (*cp != 0); cp++) 
            ;  /* noop */
        if (cp == &arg_buf[procargssize])
            continue; /* effectively a break */

        /*
         * check for overrun into env
         */
        if ((*argN != '-') && strchr(argN,'='))  {
            DEBUGMSGTL(("swrun:load:arch:_cn", " *** OVERRUN INTO ENV %d\n",nargs));
            continue;
        }

        /*
         * save arg
         */
        if(entry->hrSWRunParameters_len < sizeof(entry->hrSWRunParameters)-1) {
            strlcat(&entry->hrSWRunParameters[entry->hrSWRunParameters_len],
                    argN, sizeof(entry->hrSWRunParameters)-entry->hrSWRunParameters_len-1);
            entry->hrSWRunParameters_len = strlen(entry->hrSWRunParameters);
            if ((entry->hrSWRunParameters_len+2 < sizeof(entry->hrSWRunParameters)-1) && (0 != nargs)) {
                /* add space between params */
                entry->hrSWRunParameters[entry->hrSWRunParameters_len++] = ' ';
                entry->hrSWRunParameters[entry->hrSWRunParameters_len] = 0;
            } else {
                DEBUGMSGTL(("swrun:load:arch:_cn"," truncating long arg list\n"));
                entry->hrSWRunParameters[entry->hrSWRunParameters_len++] = '$';
                entry->hrSWRunParameters[entry->hrSWRunParameters_len] = '0';
            }
        }
    }
    if (' ' == entry->hrSWRunParameters[entry->hrSWRunParameters_len])
        entry->hrSWRunParameters[entry->hrSWRunParameters_len--] = 0;

    
    /* Get the basename of command. */
    for (command--; command >= command_beg; command--) {
        if (*command == '/')
            break;
    }
    command++;
    
    /* Allocate space for the command and copy. */
    if (strncmp(command, entry->hrSWRunName, sizeof(entry->hrSWRunName)-1)) {
        strlcpy(entry->hrSWRunName, command, sizeof(entry->hrSWRunName));
        entry->hrSWRunName_len = strlen(entry->hrSWRunName);
        DEBUGMSGTL(("swrun:load:arch:_cn",
                    " **updated name to %s\n", entry->hrSWRunName));
    }

    return 0;
}
#endif
