/*
 * dfile.c - /dev/kmem-based HP-UX file processing functions for lsof
 */

/*
 * Copyright 1994 Purdue Research Foundation, West Lafayette, Indiana
 * 47907.  All rights reserved.
 *
 * Written by Victor A. Abell
 *
 * This software is not subject to any license of the American Telephone
 * and Telegraph Company or the Regents of the University of California.
 *
 * Permission is granted to anyone to use this software for any purpose on
 * any computer system, and to alter it and redistribute it freely, subject
 * to the following restrictions:
 *
 * 1. Neither the authors nor Purdue University are responsible for any
 *    consequences of the use of this software.
 *
 * 2. The origin of this software must not be misrepresented, either by
 *    explicit claim or by omission.  Credit to the authors and Purdue
 *    University must appear in documentation and sources.
 *
 * 3. Altered versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 * 4. This notice may not be removed or altered.
 */

#ifndef lint
static char copyright[] =
    "@(#) Copyright 1994 Purdue Research Foundation.\nAll rights reserved.\n";
#endif

#if defined(HPUXKERNBITS) && HPUXKERNBITS >= 64
#    define _TIME_T
typedef int time_t;
/*
 * CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!!
 *
 * Do NOT:
 *
 *	#define INO_T
 *	typedef int ino_t;
 *
 * in this source file for HP-UX >= 10.30.  Doing so will cause the kernel's
 * ino_t type to be erroneously used instead of the application's.
 *
 * CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!! CAUTION!!!
 */
#endif /* defined(HPUXKERNBITS) && HPUXKERNBITS>=64 */

#include "common.h"

/*
 * get_max_fd() - get maximum file descriptor plus one
 */

int get_max_fd() {
    struct rlimit r;

    if (getrlimit(RLIMIT_NOFILE, &r))
        return (-1);
    return (r.rlim_cur);
}

/*
 * print_dev() - print device
 */

char *print_dev(struct lfile *lf, /* file whose device is to be printed */
                dev_t *dev)       /* device to be printed */
{
    static char buf[128];

    (void)snpf(buf, sizeof(buf), "%d,%#x", GET_MAJ_DEV(*dev),
               GET_MIN_DEV(*dev));
    return (buf);
}

/*
 * process_file() - process file
 */

void process_file(fp) KA_T fp; /* kernel file structure address */
{
    struct file f;
    int flag;

    if (kread(ctx, (KA_T)fp, (char *)&f, sizeof(f))) {
        (void)snpf(Namech, Namechl, "can't read file struct from %s",
                   print_kptr(fp, (char *)NULL, 0));
        enter_nm(Namech);
        return;
    }
    Lf->off = (SZOFFTYPE)f.f_offset;
    Lf->off_def = 1;

    if (f.f_count) {

#if defined(HASFSTRUCT)
        /*
         * Save file structure values.
         */
        Lf->fct = (long)f.f_count;
        Lf->fsv |= FSV_CT;
        Lf->fsa = fp;
        Lf->fsv |= FSV_FA;
        Lf->ffg = (long)f.f_flag;
        Lf->fsv |= FSV_FG;
        Lf->fna = (KA_T)f.f_data;
        Lf->fsv |= FSV_NI;
#endif /* defined(HASFSTRUCT) */

        /*
         * Construct access code.
         */
        if ((flag = (f.f_flag & (FREAD | FWRITE))) == FREAD)
            Lf->access = LSOF_FILE_ACCESS_READ;
        else if (flag == FWRITE)
            Lf->access = LSOF_FILE_ACCESS_WRITE;
        else if (flag == (FREAD | FWRITE))
            Lf->access = LSOF_FILE_ACCESS_READ_WRITE;
        /*
         * Process structure by its type.
         */
        switch (f.f_type) {

#if defined(DTYPE_LLA)
        case DTYPE_LLA:
            process_lla((KA_T)f.f_data);
            return;
#endif /* DTYPE_LLA */

        case DTYPE_VNODE:
            process_node((KA_T)f.f_data);
            return;
        case DTYPE_SOCKET:
            process_socket((KA_T)f.f_data);
            return;
        default:
            if (!f.f_type || (f.f_ops && (KA_T)f.f_ops != Vnfops)) {
                (void)snpf(Namech, Namechl, "%s file struct, ty=%#x, op=%#x",
                           print_kptr(fp, (char *)NULL, 0), f.f_type, f.f_ops);
                enter_nm(Namech);
                return;
            }
        }
    }
    enter_nm("no more information");
}

#if HPUXV >= 1030
/*
 * read_mi() - read stream's module information
 *
 * Note: this function is included in this module, because ino_t is not
 *	 redfined to the kernel's type, but is left at the application's type.
 *	 See the CAUTION statement inside the HPUXKERNBITS>=64 #if/#endif
 *	 block at the beginning of this file.
 */

int read_mi(sh, ip, pcb, pn)
KA_T sh;   /* stream head address */
KA_T *ip;  /* returned IP q_ptr */
KA_T *pcb; /* returned TCP or UDP q_ptr */
char **pn; /* returned protocol name */
{
    struct l_dev *dp;
    char *ep = Namech;
    struct sth_s hd;
    int i;
    size_t len, ml;
    char mn[32];
    KA_T ka, qa;
    struct module_info mi;
    struct queue q;
    struct qinit qi;
    size_t sz = Namechl;

    if (!sh || kread(ctx, sh, (char *)&hd, sizeof(hd))) {
        (void)snpf(Namech, Namechl, "can't read stream head: %s",
                   print_kptr(sh, (char *)NULL, 0));
        return (1);
    }
    if (!Lf->rdev_def)
        dp = (struct l_dev *)NULL;
    else
        dp = lkupdev(&DevDev, &Lf->rdev, 1, 0);
    if (dp)
        (void)snpf(ep, sz, "%s", dp->name);
    else
        *ep = '\0';
    /*
     * Follow the stream head to each of its queue structures, retrieving the
     * module names for each queue's q_info->qi_minfo->mi_idname chain of
     * structures.  Separate each additional name from the previous one with
     * "->".
     *
     * Ignore failures to read all but queue structure chain entries.
     *
     * Ignore module names that end in "head".
     *
     * Save the q_ptr value for "tcp" and "udp" modules.
     */
    ml = sizeof(mn) - 1;
    mn[ml] = '\0';
    *ip = *pcb = (KA_T)NULL;
    qa = (KA_T)hd.sth_wq;
    for (i = 0; i < 20; i++, qa = (KA_T)q.q_next) {
        if (!qa || kread(ctx, qa, (char *)&q, sizeof(q)))
            break;
        if (!(ka = (KA_T)q.q_qinfo) || kread(ctx, ka, (char *)&qi, sizeof(qi)))
            continue;
        if (!(ka = (KA_T)qi.qi_minfo) ||
            kread(ctx, ka, (char *)&mi, sizeof(mi)))
            continue;
        if (!(ka = (KA_T)mi.mi_idname) || kread(ctx, ka, mn, ml))
            continue;
        if ((len = strlen(mn)) < 1)
            continue;
        if (len >= 3 && !strcmp(&mn[len - 3], "sth"))
            continue;
        ep = endnm(&sz);
        (void)snpf(ep, sz, "%s%s", (ep == Namech) ? "" : "->", mn);
        if (!q.q_ptr)
            continue;
        if (!*ip && !strcmp(mn, "ip")) {
            *ip = (KA_T)q.q_ptr;
            continue;
        }
        if (!*pcb && !strcmp(mn, "tcpm")) {
            *pcb = (KA_T)q.q_ptr;
            *pn = "TCP";
            continue;
        }
        if (!*pcb && !strcmp(mn, "udpm")) {
            *pcb = (KA_T)q.q_ptr;
            *pn = "UDP";
        }
    }
    return (0);
}
#endif /* HPUXV>=1030 */
