/*
 *  Host Resources MIB - printer device group implementation - hr_print.c
 *
 */

#include <net-snmp/net-snmp-config.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include "host_res.h"
#include "hr_print.h"
#include "struct.h"
#include "util_funcs.h"

#define HRPRINT_MONOTONICALLY_INCREASING

        /*********************
	 *
	 *  Kernel & interface information,
	 *   and internal forward declarations
	 *
	 *********************/

void            Init_HR_Print(void);
int             Get_Next_HR_Print(void);
const char     *describe_printer(int);
int             printer_status(int);
int             printer_detail_status(int);
int             printer_errors(int);
int             header_hrprint(struct variable *, oid *, size_t *, int,
                               size_t *, WriteMethod **);
FILE           *run_lpstat(int *);


        /*********************
	 *
	 *  Initialisation & common implementation functions
	 *
	 *********************/

#define	HRPRINT_STATUS		1
#define	HRPRINT_ERROR		2

struct variable4 hrprint_variables[] = {
    {HRPRINT_STATUS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
     var_hrprint, 2, {1, 1}},
    {HRPRINT_ERROR, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
     var_hrprint, 2, {1, 2}}
};
oid             hrprint_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 5 };


void
init_hr_print(void)
{
    init_device[HRDEV_PRINTER] = Init_HR_Print;
    next_device[HRDEV_PRINTER] = Get_Next_HR_Print;
    /*
     * save_device[ HRDEV_PRINTER ] = Save_HR_Print;        
     */
#ifdef HRPRINT_MONOTONICALLY_INCREASING
    dev_idx_inc[HRDEV_PRINTER] = 1;
#endif

    device_descr[HRDEV_PRINTER] = describe_printer;
    device_status[HRDEV_PRINTER] = printer_status;
    device_errors[HRDEV_PRINTER] = printer_errors;

    REGISTER_MIB("host/hr_print", hrprint_variables, variable4,
                 hrprint_variables_oid);
}

/*
 * header_hrprint(...
 * Arguments:
 * vp     IN      - pointer to variable entry that points here
 * name    IN/OUT  - IN/name requested, OUT/name found
 * length  IN/OUT  - length of IN/OUT oid's 
 * exact   IN      - TRUE if an exact match was requested
 * var_len OUT     - length of variable or 0 if function returned
 * write_method
 * 
 */
int
header_hrprint(struct variable *vp,
               oid * name,
               size_t * length,
               int exact, size_t * var_len, WriteMethod ** write_method)
{
#define HRPRINT_ENTRY_NAME_LENGTH	11
    oid             newname[MAX_OID_LEN];
    int             print_idx, LowIndex = -1;
    int             result;

    DEBUGMSGTL(("host/hr_print", "var_hrprint: "));
    DEBUGMSGOID(("host/hr_print", name, *length));
    DEBUGMSG(("host/hr_print", " %d\n", exact));

    memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
    /*
     * Find "next" print entry 
     */

    Init_HR_Print();
    for (;;) {
        print_idx = Get_Next_HR_Print();
        if (print_idx == -1)
            break;
        newname[HRPRINT_ENTRY_NAME_LENGTH] = print_idx;
        result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
        if (exact && (result == 0)) {
            LowIndex = print_idx;
            /*
             * Save printer status information 
             */
            break;
        }
        if ((!exact && (result < 0)) &&
            (LowIndex == -1 || print_idx < LowIndex)) {
            LowIndex = print_idx;
            /*
             * Save printer status information 
             */
#ifdef HRPRINT_MONOTONICALLY_INCREASING
            break;
#endif
        }
    }

    if (LowIndex == -1) {
        DEBUGMSGTL(("host/hr_print", "... index out of range\n"));
        return (MATCH_FAILED);
    }

    memcpy((char *) name, (char *) newname,
           (vp->namelen + 1) * sizeof(oid));
    *length = vp->namelen + 1;
    *write_method = (WriteMethod*)0;
    *var_len = sizeof(long);    /* default to 'long' results */

    DEBUGMSGTL(("host/hr_print", "... get print stats "));
    DEBUGMSGOID(("host/hr_print", name, *length));
    DEBUGMSG(("host/hr_print", "\n"));
    return LowIndex;
}


        /*********************
	 *
	 *  System specific implementation functions
	 *
	 *********************/


u_char         *
var_hrprint(struct variable * vp,
            oid * name,
            size_t * length,
            int exact, size_t * var_len, WriteMethod ** write_method)
{
    int             print_idx;

    print_idx =
        header_hrprint(vp, name, length, exact, var_len, write_method);
    if (print_idx == MATCH_FAILED)
        return NULL;


    switch (vp->magic) {
    case HRPRINT_STATUS:
        long_return = printer_detail_status(print_idx);
        return (u_char *) & long_return;
    case HRPRINT_ERROR:
#if NETSNMP_NO_DUMMY_VALUES
        return NULL;
#else
        long_return = 0;        /* Null string */
        return (u_char *) & long_return;
#endif
    default:
        DEBUGMSGTL(("host/hr_print", "unknown sub-id %d in var_hrprint\n",
                    vp->magic));
    }
    return NULL;
}


        /*********************
	 *
	 *  Internal implementation functions
	 *
	 *********************/

static int      HRP_index;
static char   **HRP_name;
static int      HRP_nbrnames;
#if HAVE_LPSTAT || HAVE_CGETNEXT || HAVE_PRINTCAP
static int      HRP_maxnames;
#endif

#define HRP_MAX_INCR 10

void
Init_HR_Print(void)
{
#if HAVE_LPSTAT || HAVE_CGETNEXT || HAVE_PRINTCAP
    int             i;
#if HAVE_PRINTCAP
    FILE           *p;
#elif HAVE_CGETNEXT
    const char     *caps[] = { "/etc/printcap", NULL };
#elif HAVE_LPSTAT
    int	            fd;
    FILE           *p;
#endif

    HRP_index = 0;		/* fail safe at Get_Next_HR_Print */

    if (HRP_name) {
        for (i = 0; i < HRP_nbrnames; i++)
            free(HRP_name[i]);
        HRP_nbrnames = 0;
        HRP_maxnames = 0;
        SNMP_FREE(HRP_name);
    }

#if HAVE_PRINTCAP
    if ((p = fopen("/etc/printcap", "r")) != NULL) {
        char            buf[BUFSIZ], *ptr;
        while (fgets(buf, sizeof buf, p)) {
            buf[strlen(buf) - 1] = 0;
            if (buf[0] == '#' || buf[0] == 0 || buf[0] == ' '
                || buf[0] == '\t')
                continue;
            if ((ptr = strchr(buf, '\\')))
                *ptr = 0;
            if ((ptr = strchr(buf, ':')))
                *ptr = 0;
            if ((ptr = strchr(buf, '|')))
                *ptr = 0;
            ptr = buf;
#elif HAVE_CGETNEXT
    {
        char           *buf = NULL, *ptr;
        while (cgetnext(&buf, caps) > 0) {
            if ((ptr = strchr(buf, ':')))
                *ptr = 0;
            if ((ptr = strchr(buf, '|')))
                *ptr = 0;
            ptr = buf;
#elif HAVE_LPSTAT
    if ((p = run_lpstat(&fd)) != NULL) {
        char            buf[BUFSIZ], ptr[BUFSIZ];
        while (fgets(buf, sizeof buf, p)) {
            sscanf(buf, "%*s %*s %[^:]", ptr);
#endif
            if (HRP_nbrnames == HRP_maxnames) {
                char          **tmp;
                tmp = (char **) calloc(HRP_maxnames + HRP_MAX_INCR, sizeof(char *));
                if (!tmp)
                    goto finish;
		if (HRP_name) {
			memcpy(tmp, HRP_name, HRP_nbrnames * sizeof(char *));
			free(HRP_name);
		}
                HRP_maxnames += HRP_MAX_INCR;
                HRP_name = tmp;
            }
            HRP_name[HRP_nbrnames++] = strdup(ptr);
#if !defined(HAVE_PRINTCAP) && defined(HAVE_CGETNEXT)
            if (buf)
                free(buf);
#endif
        }
finish:
#if HAVE_PRINTCAP
        fclose(p);
#elif HAVE_CGETNEXT
        cgetclose();
#elif HAVE_LPSTAT
        fclose(p);
        close(fd);
#endif
    }
#endif                          /* HAVE_anything */
}

int
Get_Next_HR_Print(void)
{
    /*
     * The initial implementation system
     *   has no printers attached, and I've
     *   no real idea how to detect them,
     *   so don't bother.
     */
    if (HRP_index < HRP_nbrnames)  /* No printer */
        return (HRDEV_PRINTER << HRDEV_TYPE_SHIFT) + HRP_index++;
    else
        return -1;
}

const char     *
describe_printer(int idx)
{
    if (HRP_index == 0)  /* return empty string if not initialized */
	return "";

    DEBUGMSGTL(("host/hr_print", "describe p: %d/%d %s\n", HRP_index, idx,
                HRP_name[HRP_index - 1]));
    return HRP_name[HRP_index - 1];
}

int
printer_status(int idx)
{
    /*
     * hrDeviceStatus OBJECT-TYPE
     * SYNTAX     INTEGER {
     * unknown(1), running(2), warning(3), testing(4), down(5)
     * }
     */

    return 1;                   /* unknown */
}

int
printer_detail_status(int idx)
{
    /*
     * hrPrinterStatus OBJECT-TYPE
     * SYNTAX     INTEGER {
     * other(1), unknown(2), idle(3), printing(4), warmup(5)
     * }
     */

    return 2;                   /* unknown */
}

int
printer_errors(int idx)
{
    return 0;
}

#ifdef        HAVE_LPSTAT
/*
 * Run the lpstat command. If compiled with EXCACHE support, this
 * will actually cache the output for a while which helps a lot
 * with snmpbulkwalk (in fact, it keeps the client from exiting
 * due to timeouts).
 */
FILE           *
run_lpstat(int *fd)
{
    struct extensible ex;

    memset(&ex, 0, sizeof(ex));
    ex.command = strdup(LPSTAT_PATH " -v");
    *fd = get_exec_output(&ex);
    free(ex.command);
    return *fd >= 0 ? fdopen(*fd, "r") : NULL;
}
#endif
