/*

 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * This source code is provided to illustrate the usage of a given feature

 * or technique and has been deliberately simplified. Additional steps

 * required for a production-quality application, such as security checks,

 * input validation and proper error handling, might not be present in

 * this sample code.

 */

/* Functionality for checking hprof format=b output. */

/* ONLY used with logflags=4. */

/* Verifies and write a verbose textual version of a format=b file.

 *   Textual output file is gdata->checkfilename, fd is gdata->check_fd.

 *   Buffer is in gdata too, see gdata->check* variables.

 *   Could probably be isolated to a separate library or utility.

 */

#include "hprof.h"

typedef TableIndex HprofId;

#include "hprof_b_spec.h"

static int type_size[ /*HprofType*/ ] =  HPROF_TYPE_SIZES;

/* For map from HPROF_UTF8 to a string */

typedef struct UmapInfo {

    char *str;

} UmapInfo;

/* Field information */

typedef struct Finfo {

    HprofId   id;

    HprofType ty;

} Finfo;

/* Class information map from class ID (ClassIndex) to class information */

typedef struct CmapInfo {

    int      max_finfo;

    int      n_finfo;

    Finfo   *finfo;

    int      inst_size;

    HprofId  sup;

} CmapInfo;

/* Read raw bytes from the file image, update the pointer */

static void

read_raw(unsigned char **pp, unsigned char *buf, int len)

{

    while ( len > 0 ) {

        *buf = **pp;

        buf++;

        (*pp)++;

        len--;

    }

}

/* Read various sized elements, properly converted from big to right endian.

 *    File will contain big endian format.

 */

static unsigned

read_u1(unsigned char **pp)

{

    unsigned char b;

    read_raw(pp, &b, 1);

    return b;

}

static unsigned

read_u2(unsigned char **pp)

{

    unsigned short s;

    read_raw(pp, (void*)&s, 2);

    return md_htons(s);

}

static unsigned

read_u4(unsigned char **pp)

{

    unsigned int u;

    read_raw(pp, (void*)&u, 4);

    return md_htonl(u);

}

static jlong

read_u8(unsigned char **pp)

{

    unsigned int high;

    unsigned int low;

    jlong        x;

    high = read_u4(pp);

    low  = read_u4(pp);

    x = high;

    x = (x << 32) | low;

    return x;

}

static HprofId

read_id(unsigned char **pp)

{

    return (HprofId)read_u4(pp);

}

/* System error routine */

static void

system_error(const char *system_call, int rc, int errnum)

{

    char buf[256];

    char details[256];

    details[0] = 0;

    if ( errnum != 0 ) {

        md_system_error(details, (int)sizeof(details));

    } else if ( rc >= 0 ) {

        (void)strcpy(details,"Only part of buffer processed");

    }

    if ( details[0] == 0 ) {

        (void)strcpy(details,"Unknown system error condition");

    }

    (void)md_snprintf(buf, sizeof(buf), "System %s failed: %s\n",

                            system_call, details);

    HPROF_ERROR(JNI_TRUE, buf);

}

/* Write to a fd */

static void

system_write(int fd, void *buf, int len)

{

    int res;

    HPROF_ASSERT(fd>=0);

    res = md_write(fd, buf, len);

    if (res < 0 || res!=len) {

        system_error("write", res, errno);

    }

}

/* Flush check buffer */

static void

check_flush(void)

{

    if ( gdata->check_fd < 0 ) {

        return;

    }

    if (gdata->check_buffer_index) {

        system_write(gdata->check_fd, gdata->check_buffer, gdata->check_buffer_index);

        gdata->check_buffer_index = 0;

    }

}

/* Read out a given typed element */

static jvalue

read_val(unsigned char **pp, HprofType ty)

{

    jvalue        val;

    static jvalue empty_val;

    val = empty_val;

    switch ( ty ) {

        case 0:

        case HPROF_ARRAY_OBJECT:

        case HPROF_NORMAL_OBJECT:

            val.i = read_id(pp);

            break;

        case HPROF_BYTE:

        case HPROF_BOOLEAN:

            val.b = read_u1(pp);

            break;

        case HPROF_CHAR:

        case HPROF_SHORT:

            val.s = read_u2(pp);

            break;

        case HPROF_FLOAT:

        case HPROF_INT:

            val.i = read_u4(pp);

            break;

        case HPROF_DOUBLE:

        case HPROF_LONG:

            val.j = read_u8(pp);

            break;

        default:

            HPROF_ERROR(JNI_TRUE, "bad type number");

            break;

    }

    return val;

}

/* Move arbitrary byte stream into gdata->check_fd */

static void

check_raw(void *buf, int len)

{

    if ( gdata->check_fd < 0 ) {

        return;

    }

    if ( len <= 0 ) {

        return;

    }

    if (gdata->check_buffer_index + len > gdata->check_buffer_size) {

        check_flush();

        if (len > gdata->check_buffer_size) {

            system_write(gdata->check_fd, buf, len);

            return;

        }

    }

    (void)memcpy(gdata->check_buffer + gdata->check_buffer_index, buf, len);

    gdata->check_buffer_index += len;

}

/* Printf for gdata->check_fd */

static void

check_printf(char *fmt, ...)

{

    char    buf[1024];

    va_list args;

    if ( gdata->check_fd < 0 ) {

        return;

    }

    va_start(args, fmt);

    (void)md_vsnprintf(buf, sizeof(buf), fmt, args);

    buf[sizeof(buf)-1] = 0;

    check_raw(buf, (int)strlen(buf));

    va_end(args);

}

/* Printf of an element for gdata->check_fd */

static void

check_printf_val(HprofType ty, jvalue val, int long_form)

{

    jint low;

    jint high;

    switch ( ty ) {

        case HPROF_ARRAY_OBJECT:

            check_printf("0x%08x", val.i);

            break;

        case HPROF_NORMAL_OBJECT:

            check_printf("0x%08x", val.i);

            break;

        case HPROF_BOOLEAN:

            check_printf("0x%02x", val.b);

            break;

        case HPROF_CHAR:

            if ( long_form ) {

                if ( val.s < 0 || val.s > 0x7f || !isprint(val.s) ) {

                    check_printf("0x%04x", val.s);

                } else {

                    check_printf("0x%04x(%c)", val.s, val.s);

                }

            } else {

                if ( val.s < 0 || val.s > 0x7f || !isprint(val.s) ) {

                    check_printf("\\u%04x", val.s);

                } else {

                    check_printf("%c", val.s);

                }

            }

            break;

        case HPROF_FLOAT:

            low  = jlong_low(val.j);

            check_printf("0x%08x(%f)", low, (double)val.f);

            break;

        case HPROF_DOUBLE:

            high = jlong_high(val.j);

            low  = jlong_low(val.j);

            check_printf("0x%08x%08x(%f)", high, low, val.d);

            break;

        case HPROF_BYTE:

            check_printf("0x%02x", val.b);

            break;

        case HPROF_SHORT:

            check_printf("0x%04x", val.s);

            break;

        case HPROF_INT:

            check_printf("0x%08x", val.i);

            break;

        case HPROF_LONG:

            high = jlong_high(val.j);

            low  = jlong_low(val.j);

            check_printf("0x%08x%08x", high, low);

            break;

    }

}

/* Printf of a string for gdata->check_fd */

static void

check_printf_str(char *str)

{

    int len;

    int i;

    if ( str == NULL ) {

        check_printf("<null>");

    }

    check_printf("\"");

    len = (int)strlen(str);

    for (i = 0; i < len; i++) {

        unsigned char c;

        c = str[i];

        if ( isprint(c) ) {

            check_printf("%c", c);

        } else {

            check_printf("\\x%02x", c);

        }

    }

    check_printf("\"");

}

/* Printf of a utf8 id for gdata->check_fd */

static void

check_print_utf8(struct LookupTable *utab, char *prefix, HprofId id)

{

    TableIndex uindex;

    if ( id == 0 ) {

        check_printf("%s0x%x", prefix, id);

    } else {

        uindex = table_find_entry(utab, &id, sizeof(id));

        if ( uindex == 0 ) {

            check_printf("%s0x%x", prefix, id);

        } else {

            UmapInfo *umap;

            umap = (UmapInfo*)table_get_info(utab, uindex);

            HPROF_ASSERT(umap!=NULL);

            HPROF_ASSERT(umap->str!=NULL);

            check_printf("%s0x%x->", prefix, id);

            check_printf_str(umap->str);

        }

    }

}

/* Add a instance field information to this cmap. */

static void

add_inst_field_to_cmap(CmapInfo *cmap, HprofId id, HprofType ty)

{

   int i;

   HPROF_ASSERT(cmap!=NULL);

   i = cmap->n_finfo++;

   if ( i+1 >= cmap->max_finfo ) {

       int    osize;

       Finfo *new_finfo;

       osize            = cmap->max_finfo;

       cmap->max_finfo += 12;

       new_finfo = (Finfo*)HPROF_MALLOC(cmap->max_finfo*(int)sizeof(Finfo));

       (void)memset(new_finfo,0,cmap->max_finfo*(int)sizeof(Finfo));

       if ( i == 0 ) {

           cmap->finfo = new_finfo;

       } else {

           (void)memcpy(new_finfo,cmap->finfo,osize*(int)sizeof(Finfo));

           HPROF_FREE(cmap->finfo);

           cmap->finfo = new_finfo;

       }

   }

   cmap->finfo[i].id = id;

   cmap->finfo[i].ty = ty;

}

/* LookupTable callback for cmap entry cleanup */

static void

cmap_cleanup(TableIndex i, void *key_ptr, int key_len, void*info, void*data)

{

    CmapInfo *cmap = info;

    if ( cmap == NULL ) {

        return;

    }

    if ( cmap->finfo != NULL ) {

        HPROF_FREE(cmap->finfo);

        cmap->finfo = NULL;

    }

}

/* Case label for a switch on hprof heap dump elements */

#define CASE_HEAP(name) case name: label = #name;

/* Given the heap dump data and the utf8 map, check/write the heap dump. */

static int

check_heap_tags(struct LookupTable *utab, unsigned char *pstart, int nbytes)

{

    int                 nrecords;

    unsigned char      *p;

    unsigned char      *psave;

    struct LookupTable *ctab;

    CmapInfo            cmap;

    char               *label;

    unsigned            tag;

    HprofType           ty;

    HprofId             id, id2, fr, sup;

    int                 num_elements;

    int                 num_bytes;

    SerialNumber        trace_serial_num;

    SerialNumber        thread_serial_num;

    int                 npos;

    int                 i;

    int                 inst_size;

    ctab     = table_initialize("temp ctab", 64, 64, 512, sizeof(CmapInfo));

    /* First pass over heap records just fills in the CmapInfo table */

    nrecords = 0;

    p        = pstart;

    while ( p < (pstart+nbytes) ) {

        nrecords++;

        /*LINTED*/

        npos = (int)(p - pstart);

        tag  = read_u1(&p);

        switch ( tag ) {

            CASE_HEAP(HPROF_GC_ROOT_UNKNOWN)

                id = read_id(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_JNI_GLOBAL)

                id  = read_id(&p);

                id2 = read_id(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_JNI_LOCAL)

                id = read_id(&p);

                thread_serial_num = read_u4(&p);

                fr = read_u4(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_JAVA_FRAME)

                id = read_id(&p);

                thread_serial_num = read_u4(&p);

                fr = read_u4(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_NATIVE_STACK)

                id = read_id(&p);

                thread_serial_num = read_u4(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_STICKY_CLASS)

                id = read_id(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_THREAD_BLOCK)

                id = read_id(&p);

                thread_serial_num = read_u4(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_MONITOR_USED)

                id = read_id(&p);

                break;

            CASE_HEAP(HPROF_GC_ROOT_THREAD_OBJ)

                id = read_id(&p);

                thread_serial_num = read_u4(&p);

                trace_serial_num = read_u4(&p);

                break;

            CASE_HEAP(HPROF_GC_CLASS_DUMP)

                (void)memset((void*)&cmap, 0, sizeof(cmap));

                id = read_id(&p);

                trace_serial_num = read_u4(&p);

                {

                    HprofId ld, si, pr, re1, re2;

                    sup      = read_id(&p);

                    ld       = read_id(&p);

                    si       = read_id(&p);

                    pr       = read_id(&p);

                    re1      = read_id(&p);

                    re2      = read_id(&p);

                    cmap.sup = sup;

                }

                inst_size = read_u4(&p);

                cmap.inst_size = inst_size;

                num_elements = read_u2(&p);

                for(i=0; i<num_elements; i++) {

                    (void)read_u2(&p);

                    ty = read_u1(&p);

                    (void)read_val(&p, ty);

                }

                num_elements = read_u2(&p);

                for(i=0; i<num_elements; i++) {

                    (void)read_id(&p);

                    ty = read_u1(&p);

                    (void)read_val(&p, ty);

                }

                num_elements = read_u2(&p);

                for(i=0; i<num_elements; i++) {

                    HprofType ty;

                    HprofId   id;

                    id = read_id(&p);

                    ty = read_u1(&p);

                    add_inst_field_to_cmap(&cmap, id, ty);

                }

                (void)table_create_entry(ctab, &id, sizeof(id), &cmap);

                break;

            CASE_HEAP(HPROF_GC_INSTANCE_DUMP)

                id = read_id(&p);

                trace_serial_num = read_u4(&p);

                id2 = read_id(&p); /* class id */

                num_bytes = read_u4(&p);

                p += num_bytes;

                break;