/*

 * dump-metrics.c --

 *

 *      Operations to compute and dump some MIB metrics.

 *

 * Copyright (c) 2000 Frank Strauss, Technical University of Braunschweig.

 * Copyright (c) 2000 J. Schoenwaelder, Technical University of Braunschweig.

 * Copyright (c) 2002 J. Schoenwaelder, University of Osnabrueck.

 * Copyright (c) 2004 J. Schoenwaelder, International University Bremen.

 *

 * See the file "COPYING" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * @(#) $Id: dump-metrics.c 8090 2008-04-18 12:56:29Z strauss $

 */

/*

  # revisions

  # imports

  # row creations:

  # count node references in notification definitions

 */

#include <config.h>

#include <stdio.h>

#include <string.h>

#include "smi.h"

#include "smidump.h"

static int raw = 0;

static int silent = 0;

typedef struct BasetypeCounter {

    unsigned long total;

    unsigned long unknown;

    unsigned long integer32;

    unsigned long octetstring;

    unsigned long objectidentifier;

    unsigned long unsigned32;

    unsigned long integer64;

    unsigned long unsigned64;

    unsigned long float32;

    unsigned long float64;

    unsigned long float128;

    unsigned long enums;

    unsigned long bits;

    unsigned long pointer;

} BasetypeCounter;

typedef struct StatusCounter {

    unsigned long total;

    unsigned long current;

    unsigned long deprecated;

    unsigned long obsolete;

} StatusCounter;

typedef struct AccessCounter {

    unsigned long total;

    unsigned long noaccess;

    unsigned long notify;

    unsigned long readonly;

    unsigned long readwrite;

} AccessCounter;

typedef struct IndexCounter {

    unsigned long total;

    unsigned long index;

    unsigned long augment;

    unsigned long reorder;

    unsigned long sparse;

    unsigned long expand;

} IndexCounter;

typedef struct IndexLenCounter {

    unsigned long total;

    unsigned long length[11];

} IndexLenCounter;

typedef struct TableLenCounter {

    unsigned long total;

    unsigned long length[81];

} TableLenCounter;

typedef struct ScalarLenCounter {

    unsigned long total;

    unsigned long length[81];

} ScalarLenCounter;

typedef struct IndexComplexityCounter {

    unsigned long total;

    unsigned long complexity[100];

} IndexComplexityCounter;

typedef struct LengthCounter {

    unsigned long total;

    unsigned long descr;

    unsigned long descr_len;

    unsigned long reference;

    unsigned long reference_len;

    unsigned long units;

    unsigned long units_len;

    unsigned long format;

    unsigned long format_len;

} LengthCounter;

typedef struct RowStatusCounter {

    unsigned long basetables;

    unsigned long rowstatus;

    unsigned long storagetype;

} RowStatusCounter;

typedef struct Metrics {

    BasetypeCounter basetypesColumns;

    BasetypeCounter basetypesScalars;

    BasetypeCounter basetypesAll;

    StatusCounter   statusTypes;

    StatusCounter   statusTables;

    StatusCounter   statusColumns;

    StatusCounter   statusScalars;

    StatusCounter   statusNotifications;

    StatusCounter   statusGroups;

    StatusCounter   statusCompliances;

    StatusCounter   statusAll;

    AccessCounter   accessColumns;

    AccessCounter   accessScalars;

    AccessCounter   accessAll;

    IndexCounter    indexTables;

    IndexLenCounter indexLenTables;

    IndexComplexityCounter indexComplexity;

    TableLenCounter tableLength;

    ScalarLenCounter scalarLength;

    LengthCounter   lengthTypes;

    LengthCounter   lengthTables;

    LengthCounter   lengthRows;

    LengthCounter   lengthColumns;

    LengthCounter   lengthScalars;

    LengthCounter   lengthNotifications;

    LengthCounter   lengthAll;

} Metrics;

typedef struct UsageCounter {

    char     *module;

    char     *name;

    unsigned count;

    struct UsageCounter *nextPtr;

} UsageCounter;

static UsageCounter *typeList = NULL;

static UsageCounter *extTypeList = NULL;

static UsageCounter *extNodeList = NULL;

static UsageCounter *extModuleList = NULL;

static UsageCounter *indexComplexityList = NULL;

#define INCR_NODE 0x01

#define INCR_TYPE 0x02

static char*

getDateString(time_t t)

{

    static char   *s = NULL;

    struct tm	  *tm;

    if (s) xfree(s);

    tm = gmtime(&t);

    smiAsprintf(&s, "%04d-%02d-%02d",

		tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);

    return s;

}

static char*

language(SmiLanguage language)

{

    return

	(language == SMI_LANGUAGE_UNKNOWN)    ? "-" :

	(language == SMI_LANGUAGE_SMIV1)      ? "SMIv1" :

	(language == SMI_LANGUAGE_SMIV2)      ? "SMIv2" :

	(language == SMI_LANGUAGE_SMING)      ? "SMIng" :

						"-";

}

static int

calcSize(SmiModule *smiModule)

{

    SmiNode *smiNode;

    SmiType *smiType;

    int size = 0;

    for (smiType = smiGetFirstType(smiModule);

	 smiType;

	 smiType = smiGetNextType(smiType)) {

	if (smiType->name) {

	    size++;

	}

    }

    for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);

	 smiNode;

	 smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {

	switch (smiNode->nodekind) {

	case SMI_NODEKIND_SCALAR:

	case SMI_NODEKIND_COLUMN:

	case SMI_NODEKIND_NOTIFICATION:

	    size++;

	    break;

	default:

	    break;

	}

    }

    return size;

}

typedef void	(*ForEachIndexFunc)	(FILE *f, SmiNode *groupNode, SmiNode *smiNode, void *data);

static void

foreachIndexDo(FILE *f, SmiNode *smiNode, ForEachIndexFunc func, void *data)

{

    SmiNode *indexNode = NULL, *iNode;

    SmiElement *smiElement;

    switch (smiNode->indexkind) {

    case SMI_INDEX_INDEX:

    case SMI_INDEX_REORDER:

	indexNode = smiNode;

	break;

    case SMI_INDEX_EXPAND:	/* TODO: we have to do more work here! */

	break;

    case SMI_INDEX_AUGMENT:

    case SMI_INDEX_SPARSE:

	indexNode = smiGetRelatedNode(smiNode);

	break;

    case SMI_INDEX_UNKNOWN:

	break;

    }

    if (indexNode) {

	for (smiElement = smiGetFirstElement(indexNode);

	     smiElement; smiElement = smiGetNextElement(smiElement)) {

	    iNode = smiGetElementNode(smiElement);

	    if (iNode) {

		(func) (f, smiNode, iNode, data);

	    }

	}

    }

}

static UsageCounter*

incrUsageCounter(UsageCounter *uCntList, char *module, char *name, int incr)

{

    UsageCounter *uCnt;

    for (uCnt = uCntList; uCnt; uCnt = uCnt->nextPtr) {

	if (strcmp(uCnt->module, module) == 0

	    && (! name || strcmp(uCnt->name, name) == 0)) {

	    break;

	}

    }

    if (! uCnt) {

	uCnt = (UsageCounter *) xmalloc(sizeof(UsageCounter));

	uCnt->module = xstrdup(module);

	uCnt->name = name ? xstrdup(name) : NULL;

	uCnt->count = 0;

	uCnt->nextPtr = uCntList;

	uCntList = uCnt;

    }

    uCnt->count += incr;

    return uCntList;

}

static void

incrTypeAndNodeUsageCounter(SmiModule *smiModule, SmiNode *smiNode, int flags)

{

    SmiType *smiType;

    char *extModule;

    /*

     * First check whether the node is external. If yes, increment the

     * external node counter and we are done.

     */

    extModule = smiGetNodeModule(smiNode)->name;

    if (extModule

	&& strcmp(extModule, smiModule->name) != 0) {

	if (flags & INCR_NODE) {

	    extNodeList = incrUsageCounter(extNodeList,

					   extModule, smiNode->name, 1);

	    extModuleList = incrUsageCounter(extModuleList, extModule, NULL, 1);

	}

	return;

    }

    /*

     * Next, check whether the type of the node is external. If yes,

     * increment the external type counter and we are done. Do not

     * count base types (that is types that have no parent type).

     */

    smiType = smiGetNodeType(smiNode);

    if (! smiType) {

	return;

    }

    if (smiType->name && smiGetParentType(smiType)) {

	char *extModule = smiGetTypeModule(smiType)->name;

	if (extModule /* && *extModule */

	    && strcmp(extModule, smiModule->name) != 0) {

	    if (flags & INCR_TYPE) {

		extTypeList = incrUsageCounter(extTypeList,

					       extModule, smiType->name, 1);

		extModuleList = incrUsageCounter(extModuleList, extModule, NULL, 1);

	    }

	}

    }

    /*

     * Finally, count the type name (whether external or not does not

     * matter here nor does it matter whether it is a base type or

     * not).

     */

    if (! smiType->name && smiGetParentType(smiType)) {

	smiType = smiGetParentType(smiType);

    }

    typeList = incrUsageCounter(typeList, smiGetTypeModule(smiType)->name,

				smiType->name, 1);

}

static void

incrIndexComplexityCounter(SmiModule *smiModule, SmiNode *smiNode, int complexity)

{

    indexComplexityList = incrUsageCounter(indexComplexityList,

					   smiModule->name, smiNode->name, complexity);

}

static int

cmp(const void *va, const void *vb)

{

    UsageCounter **a = (UsageCounter **) va;

    UsageCounter **b = (UsageCounter **) vb;

    if ((*a)->count > (*b)->count) return -1;

    if ((*a)->count < (*b)->count) return 1;

    if ((*a)->module && (*b)->module) {

	int x = strcmp((*a)->module,  (*b)->module);

	if (x) return x;

    }

    if ((*a)->name && (*b)->name) {

	int x = strcmp((*a)->name,  (*b)->name);

	if (x) return x;

    }

    return 0;

}

static int

fprintRevisions(FILE *f, int modLen, SmiRevision *smiRevision,

		SmiModule *smiModule, int size)

{

    int n = 0;

    if (smiRevision) {

	n = fprintRevisions(f, modLen,

			    smiGetNextRevision(smiRevision), smiModule, -1);

	fprintf(f, "%-*s %7s  ", modLen, smiModule->name,

		(size >= 0) ? language(smiModule->language) : "-");

 	if (size >= 0) {

	    fprintf(f, "%4d", size);

	} else {

	    fprintf(f, "   -");

	}

	fprintf(f, "   %3d    %s\n", n, getDateString(smiRevision->date));

	n++;

    }

    if (!smiRevision && size >= 0) {

	fprintf(f, "%-*s %7s  ", modLen, smiModule->name,

		language(smiModule->language));

	fprintf(f, "%4d", size);

	fprintf(f, "     -    ----------\n");

    }

    return n;

}

static void

fprintRevision(FILE *f, int modc, SmiModule **modv)

{

    int i;

    int modLen = 8;

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

	if (modLen < strlen(modv[i]->name)) {

	    modLen = strlen(modv[i]->name);

	}

    }

    fprintf(f, "%-*s LANGUAGE SIZE REVISION DATE\n", modLen, "MODULE");

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

	fprintRevisions(f, modLen, smiGetFirstRevision(modv[i]),

			modv[i], calcSize(modv[i]));

    }

    fprintf(f, "\n");

}

static void

fprintTypeUsage(FILE *f, UsageCounter *typeUsageList)

{

    UsageCounter *uCnt;

    int modLen = 8, nameLen = 8;

    unsigned total = 0;

    int i, cnt = 0;

    UsageCounter **sortCnt;

    /* should be sorted */

    for (uCnt = typeUsageList, cnt = 0; uCnt; uCnt = uCnt->nextPtr, cnt++) {

	if (modLen < strlen(uCnt->module)) {

	    modLen = strlen(uCnt->module);

	}

	if (nameLen < strlen(uCnt->name)) {

	    nameLen = strlen(uCnt->name);

	}

	total += uCnt->count;

    }

    if (cnt == 0) {

	return;

    }

    /* create an array for a quick qsort */

    sortCnt = (UsageCounter **) xmalloc(cnt * sizeof(UsageCounter *));

    memset(sortCnt, 0, cnt * sizeof(UsageCounter *));

    for (uCnt = typeUsageList, i = 0; uCnt; uCnt = uCnt->nextPtr, i++) {

	sortCnt[i] = uCnt;

    }

    qsort(sortCnt, cnt, sizeof(UsageCounter *), cmp);

    if (! silent) {

	fputs(

"# The following table shows the distribution of the number of references\n"

"# to defined types (including base types) in the set of loaded MIB\n"

"# modules.\n"

"\n", f);

    }

    fprintf(f, "%-*s %-*s   USAGE\n", modLen, "MODULE", nameLen, "TYPE");

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

	fprintf(f, "%-*s %-*s ",

		modLen, sortCnt[i]->module, nameLen, sortCnt[i]->name);

	if (raw) {

	    fprintf(f, "%8u\n", sortCnt[i]->count);

	} else {

	    fprintf(f, "%6.1f%%\n", (double) sortCnt[i]->count * 100 / total);

	}

    }

    xfree(sortCnt);

}

static void

fprintExtTypeUsage(FILE *f, UsageCounter *typeUsageList)

{

    UsageCounter *uCnt;

    int modLen = 8, nameLen = 8;

    unsigned total = 0;

    int i, cnt = 0;

    UsageCounter **sortCnt;

    /* should be sorted */

    for (uCnt = typeUsageList, cnt = 0; uCnt; uCnt = uCnt->nextPtr, cnt++) {

	if (modLen < strlen(uCnt->module)) {

	    modLen = strlen(uCnt->module);

	}

	if (nameLen < strlen(uCnt->name)) {

	    nameLen = strlen(uCnt->name);

	}

	total += uCnt->count;

    }

    if (cnt == 0) {

	return;

    }

    /* create an array for a quick qsort */

    sortCnt = (UsageCounter **) xmalloc(cnt * sizeof(UsageCounter *));

    memset(sortCnt, 0, cnt * sizeof(UsageCounter *));

    for (uCnt = typeUsageList, i = 0; uCnt; uCnt = uCnt->nextPtr, i++) {

	sortCnt[i] = uCnt;

    }

    qsort(sortCnt, cnt, sizeof(UsageCounter *), cmp);

    if (! silent) {

	fputs(

"# The following table shows the distribution of the number of references\n"

"# to externally defined types (excluding base types) in the set of loaded\n"

"# MIB modules.\n"

"\n", f);

    }

    fprintf(f, "%-*s %-*s EXT-USAGE\n", modLen, "MODULE", nameLen, "TYPE");

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

	fprintf(f, "%-*s %-*s ",

		modLen, sortCnt[i]->module, nameLen, sortCnt[i]->name);

	if (raw) {

	    fprintf(f, "%8u\n", sortCnt[i]->count);

	} else {

	    fprintf(f, "%6.1f%%\n", (double) sortCnt[i]->count * 100 / total);

	}

    }

    xfree(sortCnt);

}

static void

fprintExtNodeUsage(FILE *f, UsageCounter *typeUsageList)

{

    UsageCounter *uCnt;

    int modLen = 8, nameLen = 8;

    unsigned total = 0;

    int i, cnt = 0;

    UsageCounter **sortCnt;

    /* should be sorted */

    for (uCnt = typeUsageList, cnt = 0; uCnt; uCnt = uCnt->nextPtr, cnt++) {

	if (modLen < strlen(uCnt->module)) {

	    modLen = strlen(uCnt->module);

	}

	if (nameLen < strlen(uCnt->name)) {

	    nameLen = strlen(uCnt->name);

	}

	total += uCnt->count;

    }

    if (cnt == 0) {

	return;

    }

    /* create an array for a quick qsort */

    sortCnt = (UsageCounter **) xmalloc(cnt * sizeof(UsageCounter *));

    memset(sortCnt, 0, cnt * sizeof(UsageCounter *));

    for (uCnt = typeUsageList, i = 0; uCnt; uCnt = uCnt->nextPtr, i++) {

	sortCnt[i] = uCnt;

    }

    qsort(sortCnt, cnt, sizeof(UsageCounter *), cmp);

    if (! silent) {

	fputs(

"# The following table shows the distribution of the number of references\n"

"# to externally defined nodes in the set of loaded MIB modules.\n"

"\n", f);

    }

    fprintf(f, "%-*s %-*s EXT-USAGE\n", modLen, "MODULE", nameLen, "NODE");

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

	fprintf(f, "%-*s %-*s ",

		modLen, sortCnt[i]->module, nameLen, sortCnt[i]->name);

	if (raw) {

	    fprintf(f, "%8u\n", sortCnt[i]->count);

	} else {

	    fprintf(f, "%6.1f%%\n", (double) sortCnt[i]->count * 100 / total);

	}

    }

    xfree(sortCnt);

}

static void

fprintModuleUsage(FILE *f, UsageCounter *modUsageList)

{

    UsageCounter *uCnt;

    int modLen = 8;

    unsigned total = 0;

    int i, cnt = 0;

    UsageCounter **sortCnt;

    /* should be sorted */

    for (uCnt = modUsageList, cnt = 0; uCnt; uCnt = uCnt->nextPtr, cnt++) {

	if (modLen < strlen(uCnt->module)) {

	    modLen = strlen(uCnt->module);

	}

	total += uCnt->count;

    }

    if (cnt == 0) {

	return;

    }

    /* create an array for a quick qsort */

    sortCnt = (UsageCounter **) xmalloc(cnt * sizeof(UsageCounter *));

    memset(sortCnt, 0, cnt * sizeof(UsageCounter *));

    for (uCnt = modUsageList, i = 0; uCnt; uCnt = uCnt->nextPtr, i++) {

	sortCnt[i] = uCnt;

    }

    qsort(sortCnt, cnt, sizeof(UsageCounter *), cmp);

    if (! silent) {

	fputs(

"# The following table shows the distribution of the number of references\n"

"# to externally defined items (such as types or objects) accumulated by\n"

"# the defining MIB module in the set of loaded MIB modules.\n"

"\n", f);

    }

    fprintf(f, "%-*s EXT-USAGE\n", modLen, "MODULE");

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

	fprintf(f, "%-*s ", modLen, sortCnt[i]->module);

	if (raw) {

	    fprintf(f, "%8u\n", sortCnt[i]->count);

	} else {

	    fprintf(f, "%6.1f%%\n", (double) sortCnt[i]->count * 100 / total);

	}

    }

    xfree(sortCnt);

}

static void

fprintIndexComplexity(FILE *f, UsageCounter *modUsageList)

{

    UsageCounter *uCnt;

    int modLen = 8;

    int nameLen = 8;

    unsigned total = 0;

    int i, cnt = 0;

    UsageCounter **sortCnt;

    /* should be sorted */

    for (uCnt = modUsageList, cnt = 0; uCnt; uCnt = uCnt->nextPtr, cnt++) {

	if (modLen < strlen(uCnt->module)) {

	    modLen = strlen(uCnt->module);

	}

	if (nameLen < strlen(uCnt->name)) {

	    nameLen = strlen(uCnt->name);

	}

	total += uCnt->count;

    }

    if (cnt == 0) {

	return;

    }

    /* create an array for a quick qsort */

    sortCnt = (UsageCounter **) xmalloc(cnt * sizeof(UsageCounter *));

    memset(sortCnt, 0, cnt * sizeof(UsageCounter *));

    for (uCnt = modUsageList, i = 0; uCnt; uCnt = uCnt->nextPtr, i++) {

	sortCnt[i] = uCnt;

    }

    qsort(sortCnt, cnt, sizeof(UsageCounter *), cmp);

    if (! silent) {

	fputs(

"# The following table shows the distribution of the index complexity\n"

"# in the set of loaded MIB modules.\n"

"\n", f);

    }

    fprintf(f, "%-*s %-*s COMPLEXITY\n", modLen, "MODULE", nameLen, "TABLE");

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

	fprintf(f, "%-*s %-*s ", modLen, sortCnt[i]->module, nameLen, sortCnt[i]->name);

	if (raw) {

	    fprintf(f, "%8u\n", sortCnt[i]->count);

	} else {

	    fprintf(f, "%6.1f%%\n", (double) sortCnt[i]->count);

	}

    }

    xfree(sortCnt);

}

static void

freeUsageCounter(UsageCounter *usageCounterList)

{

    UsageCounter *uCnt, *p;

    for (uCnt = usageCounterList; uCnt; ) {

	p = uCnt, uCnt = uCnt->nextPtr;

	xfree(p->module);

	xfree(p->name);

	xfree(p);

    }

}

static void

incrBasetypeCounter(BasetypeCounter *basetypeCounter, SmiNode *smiNode)

{

    SmiType *smiType;

    smiType = smiGetNodeType(smiNode);

    if (smiType) {

	basetypeCounter->total++;

	switch (smiType->basetype) {

	case SMI_BASETYPE_UNKNOWN:

	    basetypeCounter->unknown++;

	    break;

	case SMI_BASETYPE_INTEGER32:

	    basetypeCounter->integer32++;

	    break;

	case SMI_BASETYPE_OCTETSTRING:

	    basetypeCounter->octetstring++;

	    break;

	case SMI_BASETYPE_OBJECTIDENTIFIER:

	    basetypeCounter->objectidentifier++;

	    break;

	case SMI_BASETYPE_UNSIGNED32:

	    basetypeCounter->unsigned32++;

	    break;

	case SMI_BASETYPE_INTEGER64:

	    basetypeCounter->integer64++;

	    break;

	case SMI_BASETYPE_UNSIGNED64:

	    basetypeCounter->unsigned64++;

	    break;

	case SMI_BASETYPE_FLOAT32:

	    basetypeCounter->float32++;

	    break;

	case SMI_BASETYPE_FLOAT64:

	    basetypeCounter->float64++;

	    break;

	case SMI_BASETYPE_FLOAT128:

	    basetypeCounter->float128++;

	    break;

	case SMI_BASETYPE_ENUM:

	    basetypeCounter->enums++;

	    break;

	case SMI_BASETYPE_BITS:

	    basetypeCounter->bits++;

	    break;

	case SMI_BASETYPE_POINTER:

	    basetypeCounter->pointer++;

	    break;

	}

    }

}

static void

incrStatusCounter(StatusCounter *cnt, SmiStatus smiStatus)

{

    cnt->total++;

    switch (smiStatus) {

    case SMI_STATUS_CURRENT:

    case SMI_STATUS_MANDATORY:

    case SMI_STATUS_OPTIONAL:

	cnt->current++;

	break;

    case SMI_STATUS_DEPRECATED:

	cnt->deprecated++;

	break;

    case SMI_STATUS_OBSOLETE:

	cnt->obsolete++;

	break;

    case SMI_STATUS_UNKNOWN:

	break;

    }

}

static void

incrAccessCounter(AccessCounter *cnt, SmiAccess smiAccess)

{

    cnt->total++;

    switch (smiAccess) {

    case SMI_ACCESS_NOT_ACCESSIBLE:

	cnt->noaccess++;

	break;

    case SMI_ACCESS_NOTIFY:

	cnt->notify++;

	break;

    case SMI_ACCESS_READ_ONLY:

	cnt->readonly++;

	break;

    case SMI_ACCESS_READ_WRITE:

	cnt->readwrite++;

	break;

    case SMI_ACCESS_INSTALL:

    case SMI_ACCESS_INSTALL_NOTIFY:

    case SMI_ACCESS_REPORT_ONLY:

    case SMI_ACCESS_UNKNOWN:

    case SMI_ACCESS_NOT_IMPLEMENTED:

    case SMI_ACCESS_EVENT_ONLY:

	break;

    }

}

static void

incrIndexCounter(IndexCounter *cnt, SmiIndexkind indexkind)

{

    cnt->total++;

    switch (indexkind) {

    case SMI_INDEX_INDEX:

	cnt->index++;

	break;

    case SMI_INDEX_AUGMENT:

	cnt->augment++;

	break;

    case SMI_INDEX_REORDER:

	cnt->reorder++;

	break;

    case SMI_INDEX_SPARSE:

	cnt->sparse++;