/*

 * dump-smi.c --

 *

 *      Operations to dump SMIv1/v2 module information.

 *

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

 *

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

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

 *

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

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include "smi.h"

#include "smidump.h"

extern int smiAsprintf(char **strp, const char *format, ...);

#define  INDENT		4    /* indent factor */

#define  INDENTVALUE	16   /* column to start values, except multiline */

#define  INDENTTEXTS	 9   /* column to start multiline texts */

#define  INDENTTEXTS2	15   /* column to start indented multiline texts */

#define  INDENTMAX	72   /* max column to fill, break lines otherwise */

static char *convertTypev1[] = {

    NULL,		 "Counter32",	       NULL,	   "Counter",

    NULL,		 "Gauge32",	       NULL,	   "Gauge",

    NULL,		 "Integer32",	       NULL,	   "INTEGER",

    NULL,		 "Unsigned32",	       NULL,	   "Gauge",

    NULL,		 "Bits",	       NULL,	   "OCTET STRING",

    NULL,		 "OctetString",	       NULL,	   "OCTET STRING",

    NULL,		 "ObjectIdentifier",   NULL,	   "OBJECT IDENTIFIER",

    NULL, NULL, NULL, NULL };

static char *convertTypev2[] = {

    NULL,		 "INTEGER",	       NULL,	   "Integer32",

    NULL,		 "Enumeration",	       NULL,	   "INTEGER",

    NULL,		 "Bits",	       NULL,	   "BITS",

    NULL,		 "OctetString",	       NULL,	   "OCTET STRING",

    NULL,		 "ObjectIdentifier",   NULL,	   "OBJECT IDENTIFIER",

    NULL,		 "Counter",	       NULL,	   "Counter32",

    NULL,		 "Gauge",	       NULL,	   "Gauge32",

    NULL, NULL, NULL, NULL };

static char *convertTypePIBtoMIB[] = {

    NULL,		 "Unsigned64",	       NULL,	   "IBRUnsigned64",

    NULL,		 "Integer64",	       NULL,	   "IBRInteger64",

/* XXX This breaks SMIv2 -> SMIv? compilation such that the IMPORT statement

   for SnmpAdminString is removed. I've remove this as a quick fix, but I'm

   not sure what to do for PIB compilation here.

    NULL,		 "SnmpAdminString",    NULL,	   "OCTET STRING",

*/

    NULL, NULL, NULL, NULL };

static char *convertImportv2[] = {

    "IRTF-NMRG-SMING-TYPES", "IpAddress",       "SNMPv2-SMI", "IpAddress",

    "IRTF-NMRG-SMING-TYPES", "Counter32",       "SNMPv2-SMI", "Counter32",

    "IRTF-NMRG-SMING-TYPES", "Gauge32",	        "SNMPv2-SMI", "Gauge32",

    "IRTF-NMRG-SMING-TYPES", "TimeTicks",       "SNMPv2-SMI", "TimeTicks",

    "IRTF-NMRG-SMING-TYPES", "Opaque",	        "SNMPv2-SMI", "Opaque",

    "IRTF-NMRG-SMING-TYPES", "Counter64",       "SNMPv2-SMI", "Counter64",

    "IRTF-NMRG-SMING-TYPES", "DisplayString",   "SNMPv2-TC", "DisplayString",

    "IRTF-NMRG-SMING-TYPES", "PhysAddress",     "SNMPv2-TC", "PhysAddress",

    "IRTF-NMRG-SMING-TYPES", "MacAddress",      "SNMPv2-TC", "MacAddress",

    "IRTF-NMRG-SMING-TYPES", "TruthValue",      "SNMPv2-TC", "TruthValue",

    "IRTF-NMRG-SMING-TYPES", "TestAndIncr",     "SNMPv2-TC", "TestAndIncr",

    "IRTF-NMRG-SMING-TYPES", "AutonomousType",  "SNMPv2-TC", "AutonomousType",

    "IRTF-NMRG-SMING-TYPES", "InstancePointer", "SNMPv2-TC", "InstancePointer",

    "IRTF-NMRG-SMING-TYPES", "VariablePointer", "SNMPv2-TC", "VariablePointer",

    "IRTF-NMRG-SMING-TYPES", "RowPointer",      "SNMPv2-TC", "RowPointer",

    "IRTF-NMRG-SMING-TYPES", "RowStatus",       "SNMPv2-TC", "RowStatus",

    "IRTF-NMRG-SMING-TYPES", "TimeStamp",       "SNMPv2-TC", "TimeStamp",

    "IRTF-NMRG-SMING-TYPES", "TimeInterval",    "SNMPv2-TC", "TimeInterval",

    "IRTF-NMRG-SMING-TYPES", "DateAndTime",     "SNMPv2-TC", "DateAndTime",

    "IRTF-NMRG-SMING-TYPES", "StorageType",     "SNMPv2-TC", "StorageType",

    "IRTF-NMRG-SMING-TYPES", "TDomain",         "SNMPv2-TC", "TDomain",

    "IRTF-NMRG-SMING-TYPES", "TAddress",        "SNMPv2-TC", "TAddress",

    "IRTF-NMRG-SMING", NULL,                    "SNMPv2-SMI", NULL,

    "RFC1155-SMI", "internet",	    "SNMPv2-SMI", "internet",

    "RFC1155-SMI", "directory",	    "SNMPv2-SMI", "directory",

    "RFC1155-SMI", "mgmt",	    "SNMPv2-SMI", "mgmt",

    "RFC1155-SMI", "experimental",  "SNMPv2-SMI", "experimental",

    "RFC1155-SMI", "private",	    "SNMPv2-SMI", "private",

    "RFC1155-SMI", "enterprises",   "SNMPv2-SMI", "enterprises",

    "RFC1155-SMI", "IpAddress",     "SNMPv2-SMI", "IpAddress",

    "RFC1155-SMI", "Counter",       "SNMPv2-SMI", "Counter32",

    "RFC1155-SMI", "Gauge",         "SNMPv2-SMI", "Gauge32",

    "RFC1155-SMI", "TimeTicks",     "SNMPv2-SMI", "TimeTicks",

    "RFC1155-SMI", "Opaque",        "SNMPv2-SMI", "Opaque",

    "RFC1213-MIB", "mib-2",         "SNMPv2-SMI", "mib-2",    

    "RFC1213-MIB", "DisplayString", "SNMPv2-TC",  "DisplayString",    

/* import types for PIB to MIB conversion */

    NULL, NULL, NULL, NULL };

static char *convertImportv1[] = {

    "IRTF-NMRG-SMING-TYPES", "IpAddress",   "RFC1155-SMI", "IpAddress",

    "IRTF-NMRG-SMING-TYPES", "Counter32",   "RFC1155-SMI", "Counter",

    "IRTF-NMRG-SMING-TYPES", "Gauge32",	    "RFC1155-SMI", "Gauge",

    "IRTF-NMRG-SMING-TYPES", "TimeTicks",   "RFC1155-SMI", "TimeTicks",

    "IRTF-NMRG-SMING-TYPES", "Opaque",	    "RFC1155-SMI", "Opaque",

    "IRTF-NMRG-SMING-TYPES", "Counter64",   NULL,          NULL,

    "IRTF-NMRG-SMING",       "mib-2",	    "RFC1213-MIB", "mib-2",

    "SNMPv2-SMI", "IpAddress",              "RFC1155-SMI", "IpAddress",

    "SNMPv2-SMI", "Counter32",              "RFC1155-SMI", "Counter",

    "SNMPv2-SMI", "Gauge32",	            "RFC1155-SMI", "Gauge",

    "SNMPv2-SMI", "TimeTicks",              "RFC1155-SMI", "TimeTicks",

    "SNMPv2-SMI", "Opaque",	            "RFC1155-SMI", "Opaque",

    "SNMPv2-SMI", "Integer32",	            NULL,	   NULL,

    "SNMPv2-SMI", "Unsigned32",	            NULL,	   NULL,

    "SNMPv2-SMI", "Counter64",	            NULL,	   NULL,

    "SNMPv2-SMI", "mib-2",                  "RFC1213-MIB", "mib-2",

    "SNMPv2-SMI", "MODULE-IDENTITY",        NULL,	   NULL,

    "SNMPv2-SMI", "OBJECT-IDENTITY",        NULL,	   NULL,

    "SNMPv2-SMI", "ObjectName",		    NULL,	   NULL,

    "SNMPv2-SMI", "NotificationName",       NULL,	   NULL,

    "SNMPv2-SMI", "ObjectSyntax",	    NULL,	   NULL,

    "SNMPv2-SMI", "SimpleSyntax",	    NULL,	   NULL,

    "SNMPv2-SMI", "ApplicationSyntax",      NULL,	   NULL,

    "SNMPv2-SMI", "OBJECT-TYPE",	    NULL,	   NULL,

    "SNMPv2-SMI", "NOTIFICATION-TYPE",      NULL,	   NULL,

    NULL, NULL, NULL, NULL };

static int current_column = 0;

static int smiv1 = 0;

static int silent = 0;

static int pibtomib = 0;

typedef struct Import {

    char          *module;

    char          *name;

    struct Import *nextPtr;

} Import;

static Import *importList = NULL;

static int invalidType(SmiBasetype basetype)

{

    if (smiv1) {

	return (basetype == SMI_BASETYPE_INTEGER64)

	    || (basetype == SMI_BASETYPE_UNSIGNED64)

	    || (basetype == SMI_BASETYPE_FLOAT32)

	    || (basetype == SMI_BASETYPE_FLOAT64)

	    || (basetype == SMI_BASETYPE_FLOAT128);

    } else if (!pibtomib) {

	return (basetype == SMI_BASETYPE_INTEGER64)

	    || (basetype == SMI_BASETYPE_FLOAT32)

	    || (basetype == SMI_BASETYPE_FLOAT64)

	    || (basetype == SMI_BASETYPE_FLOAT128);

    } else {

	return (basetype == SMI_BASETYPE_FLOAT32)

	    || (basetype == SMI_BASETYPE_FLOAT64)

	    || (basetype == SMI_BASETYPE_FLOAT128);

    }

}

static char *getStatusString(SmiStatus status)

{

    if (smiv1) {

	return

	    (status == SMI_STATUS_CURRENT)     ? "mandatory" :

	    (status == SMI_STATUS_DEPRECATED)  ? "deprecated" :

	    (status == SMI_STATUS_OBSOLETE)    ? "obsolete" :

	    (status == SMI_STATUS_MANDATORY)   ? "mandatory" :

	    (status == SMI_STATUS_OPTIONAL)    ? "optional" :

					         "<unknown>";

    } else {

	return

	    (status == SMI_STATUS_CURRENT)     ? "current" :

	    (status == SMI_STATUS_DEPRECATED)  ? "deprecated" :

	    (status == SMI_STATUS_OBSOLETE)    ? "obsolete" :

	    (status == SMI_STATUS_MANDATORY)   ? "current" :

	    (status == SMI_STATUS_OPTIONAL)    ? "current" :

					         "<unknown>";

    }

}

static char *getAccessString(SmiAccess access, int create)

{

    if (smiv1) {

	return

	    (access == SMI_ACCESS_NOT_ACCESSIBLE) ? "not-accessible" :

	    (access == SMI_ACCESS_NOTIFY)	  ? "read-only" :

	    (access == SMI_ACCESS_READ_ONLY)      ? "read-only" :

	    (access == SMI_ACCESS_READ_WRITE)     ? "read-write" :

						    "<unknown>";

    } else {

	if (create && (access == SMI_ACCESS_READ_WRITE)) {

	    return "read-create";

	} else {

            if (pibtomib)

                return

	        (access == SMI_ACCESS_NOT_ACCESSIBLE) ? "not-accessible" :

	        (access == SMI_ACCESS_NOTIFY)	      ? "read-only" :

	        (access == SMI_ACCESS_READ_ONLY)      ? "read-only" :

	        (access == SMI_ACCESS_READ_WRITE)     ? "read-write" :

	        (access == SMI_ACCESS_INSTALL)        ? "read-create" :

	        (access == SMI_ACCESS_INSTALL_NOTIFY) ? "read-create" :

						        "<unknown>";

            else

	        return

	        (access == SMI_ACCESS_NOT_ACCESSIBLE) ? "not-accessible" :

	        (access == SMI_ACCESS_NOTIFY)	  ? "accessible-for-notify" :

	        (access == SMI_ACCESS_READ_ONLY)      ? "read-only" :

	        (access == SMI_ACCESS_READ_WRITE)     ? "read-write" :

						        "<unknown>";

	}

    }

}

static char *getTimeString(time_t t)

{

    static char   *s = NULL;

    struct tm	  *tm;

    if (s) xfree(s);

    tm = gmtime(&t);

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

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

		tm->tm_hour, tm->tm_min);

    return s;

}

static char *getTypeString(SmiBasetype basetype, SmiType *smiType)

{

    int         i;

    char	**convertType;

    char        *typeModule, *typeName;

    typeName = smiType ? smiType->name : NULL;

    typeModule = smiType ? smiGetTypeModule(smiType)->name : NULL;

    convertType = smiv1 ? convertTypev1 : convertTypev2;

    if (typeName &&

	(basetype != SMI_BASETYPE_ENUM) &&

	(basetype != SMI_BASETYPE_BITS)) {

        if (pibtomib)

	    for(i=0; convertTypePIBtoMIB[i+1]; i += 4) {

	        if ((!strcmp(typeName, convertTypePIBtoMIB[i+1])) &&

		    ((!typeModule) || (!convertTypePIBtoMIB[i]) ||

		     (!strcmp(typeModule, convertTypePIBtoMIB[i])))) {

		    return convertTypePIBtoMIB[i+3];

	        }

	    }

	for(i=0; convertType[i+1]; i += 4) {

	    if ((!strcmp(typeName, convertType[i+1])) &&

		((!typeModule) || (!convertType[i]) ||

		 (!strcmp(typeModule, convertType[i])))) {

		return convertType[i+3];

	    }

	}

    }

    if ((!typeModule) || (!strlen(typeModule)) || (!typeName)) {

	if (basetype == SMI_BASETYPE_ENUM) {

	    return "INTEGER";

	}

	if (basetype == SMI_BASETYPE_BITS) {

	    if (smiv1) {

		return "OCTET STRING";

	    } else {

		return "BITS";

	    }

	}

    }

    /* TODO: fully qualified if unambigous */

    return typeName;

}

static char *getOidString(SmiNode *smiNode, int importedParent)

{

    SmiNode	 *parentNode;

    SmiModule	 *smiModule;

    static char	 s[200];

    char	 append[200];

    unsigned int i;

    append[0] = 0;

    parentNode = smiNode;

    smiModule = smiGetNodeModule(smiNode);

    do {

	if (parentNode->oidlen <= 1) {

	    break;

	}

	/* prepend the cut-off subidentifier to `append'. */

	strcpy(s, append);

	if (parentNode->decl != SMI_DECL_IMPL_OBJECT) {

	    sprintf(append, " %u%s", parentNode->oid[parentNode->oidlen-1], s);

	} else {

	    sprintf(append, " %s(%u)%s",

		    parentNode->name,

		    parentNode->oid[parentNode->oidlen-1], s);

	}

	/* retrieve the parent SmiNode */

	parentNode = smiGetParentNode(parentNode);

	if (!parentNode) {

	    sprintf(s, "%s", append);

	    return s;

	}

	/* found an imported or a local parent node? */

	if ((parentNode->decl != SMI_DECL_IMPL_OBJECT) &&

	    ((parentNode->name && strlen(parentNode->name)) &&

	    (smiIsImported(smiModule, NULL, parentNode->name) ||

	     (!importedParent &&

	      (smiGetNodeModule(parentNode) == smiModule)) ||

	     (parentNode->oidlen == 1)))) {

	    sprintf(s, "%s%s", parentNode->name, append);

	    return s;

	}

    } while (parentNode);

    s[0] = 0;

    for (i=0; i < smiNode->oidlen; i++) {

	if (i) strcat(s, " ");

	sprintf(&s[strlen(s)], "%u", smiNode->oid[i]);

    }

    return s;

}

static char *getUppercaseString(char *s)

{

    static char *ss;

    ss = xstrdup(s);

    ss[0] = (char)toupper((int)ss[0]);

    return ss;

}

static int isObjectGroup(SmiNode *groupNode)

{

    SmiNode     *smiNode;

    SmiElement  *smiElement;

    for (smiElement = smiGetFirstElement(groupNode); smiElement;

	 smiElement = smiGetNextElement(smiElement)) {

	smiNode = smiGetElementNode(smiElement);

	if (smiNode->nodekind != SMI_NODEKIND_SCALAR

	    && smiNode->nodekind != SMI_NODEKIND_COLUMN) {

	    return 0;

	}

    }

    return 1;

}

static int isNotificationGroup(SmiNode *groupNode)

{

    SmiNode     *smiNode;

    SmiElement  *smiElement;

    for (smiElement = smiGetFirstElement(groupNode); smiElement;

	 smiElement = smiGetNextElement(smiElement)) {

	smiNode = smiGetElementNode(smiElement);

	if (smiNode->nodekind != SMI_NODEKIND_NOTIFICATION) {

	    return 0;

	}

    }

    return 1;

}

static Import* addImport(char *module, char *name)

{

    Import **import, *newImport;

    char   **convertImport;

    int    i;

    convertImport = smiv1 ? convertImportv1 : convertImportv2;

    for (i = 0; convertImport[i]; i += 4) {

	if (convertImport[i] && convertImport[i+1]

	    && !strcmp(module, convertImport[i])

	    && !strcmp(name, convertImport[i+1])) {

	    module = convertImport[i+2];

	    name = convertImport[i+3];

	    break;

	} else if (convertImport[i] && !convertImport[i+1]

		   && !strcmp(module, convertImport[i])) {

	    module = convertImport[i+2];

	    break;

	}

    }

    if (!module || !name) {

	return NULL;

    }

    for (import = &importList; *import; import = &(*import)->nextPtr) {

	int c = strcmp((*import)->module, module);

	if (c < 0) continue;

	if (c == 0) {

	    int d = strcmp((*import)->name, name);

	    if (d < 0) continue;

	    if (d == 0) return *import;

	    if (d > 0) break;

	}

	if (c > 0) break;

    }

    newImport = xmalloc(sizeof(Import));

    if (! newImport) {

	return NULL;

    }

    newImport->module = module;

    newImport->name = name;

    newImport->nextPtr = *import;

    *import = newImport;

    return *import;

}

static void createImportList(SmiModule *smiModule)

{

    SmiNode     *smiNode;

    SmiType     *smiType;

    SmiNodekind kind = SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN;

    SmiImport   *smiImport;

    SmiModule	*smiModule2;

    if (pibtomib) {

        addImport("TUBS-SMI", "ibrpibtomib");

	for(smiType = smiGetFirstType(smiModule);

	    smiType; smiType = smiGetNextType(smiType)) {

	    if (smiType->basetype == SMI_BASETYPE_UNSIGNED32)

	        addImport("SNMPv2-SMI", "Unsigned32"); 

            else if (smiType->basetype == SMI_BASETYPE_UNSIGNED64)

	        addImport("TUBS-SMI", "IBRUnsigned64"); 

            else if (smiType->basetype == SMI_BASETYPE_INTEGER64)

	        addImport("TUBS-SMI", "IBRInteger64"); 

        }

        if (smiGetFirstNode(smiModule, SMI_NODEKIND_TABLE) != NULL)

            addImport("SNMPv2-TC", "RowStatus");

        for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ROW);

            smiNode; smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ROW)) {

            if (smiNode->indexkind == SMI_INDEX_SPARSE) {

                SmiNode *smiNode2 = smiGetRelatedNode(smiNode);

                while (smiNode2 && (smiNode2->indexkind == SMI_INDEX_SPARSE))

                    smiNode2 = smiGetRelatedNode(smiNode2);

                if (smiNode2) {

                    smiModule2 = smiGetNodeModule(smiNode2);

                    if (smiModule != smiModule2)

                        addImport(smiModule2->name, smiNode2->name);

                }

            }

        }

    }

    for(smiNode = smiGetFirstNode(smiModule, kind); smiNode;

	smiNode = smiGetNextNode(smiNode, kind)) {

	smiType = smiGetNodeType(smiNode);

	if (smiType && (smiType->decl == SMI_DECL_IMPLICIT_TYPE)) {

	    smiType = smiGetParentType(smiType);

	}

	if (smiType) {

	    smiModule2 = smiGetTypeModule(smiType);

	    if (smiModule2 && (smiModule2 != smiModule)) {

                size_t len = strlen(smiModule2->name);

		if (len && smiType->name) {

                    if (pibtomib && (len > 4) &&

                        !strcmp(&smiModule2->name[len - 4], "-PIB")) {

                        char *newName = xmalloc(len + 5);

                        strcpy(newName, smiModule2->name);

                        strcat(newName, "-MIB");

                        addImport(newName, smiType->name);

                    } else

		        addImport(smiModule2->name, smiType->name);

		}

	    }

	}

	if (pibtomib) {

            if (smiType && (smiType->basetype == SMI_BASETYPE_UNSIGNED32))

	        addImport("SNMPv2-SMI", "Unsigned32");

            if (smiType && (smiType->basetype == SMI_BASETYPE_UNSIGNED64))

	        addImport("TUBS-SMI", "IBRUnsigned64");

            if (smiType && (smiType->basetype == SMI_BASETYPE_INTEGER64))

	        addImport("TUBS-SMI", "IBRInteger64");

	}

	if (! smiv1 &&

	    smiType && smiType->basetype == SMI_BASETYPE_INTEGER32) {

	    addImport("SNMPv2-SMI", "Integer32");

	}

	if ((!smiv1) &&

	    (smiNode->value.basetype == SMI_BASETYPE_OBJECTIDENTIFIER) &&

	    (!strcmp(smiNode->value.value.ptr, "zeroDotZero"))) {

	    addImport("SNMPv2-SMI", "zeroDotZero");

	}

    }

    smiNode = smiGetFirstNode(smiModule,

			      SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN

			      | SMI_NODEKIND_TABLE | SMI_NODEKIND_ROW);

    if (smiNode) {

	addImport(smiv1 ? "RFC-1212" : "SNMPv2-SMI", "OBJECT-TYPE");

    }

    smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NOTIFICATION);

    if (smiNode) {

	addImport(smiv1 ? "RFC-1215" : "SNMPv2-SMI",

		  smiv1 ? "TRAP-TYPE" : "NOTIFICATION-TYPE");

    }

    if (! smiv1) {

	smiNode = smiGetModuleIdentityNode(smiModule);

	if (smiNode) {

	    if (strcmp("SNMPv2-SMI", smiModule->name)) {

		addImport("SNMPv2-SMI", "MODULE-IDENTITY");

	    }

	}

    }

    if (! smiv1) {

	for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NODE);

	    smiNode; smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NODE)) {

	    if (smiNode->status != SMI_STATUS_UNKNOWN &&

		smiNode != smiGetModuleIdentityNode(smiModule)) {

		if (strcmp("SNMPv2-SMI", smiModule->name)) {

		    addImport("SNMPv2-SMI", "OBJECT-IDENTITY");

		}

		break;

	    }

	}

    }

    if (! smiv1) {

	smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_COMPLIANCE);

	if (smiNode) {

	    if (strcmp("SNMPv2-CONF", smiModule->name)) {

		addImport("SNMPv2-CONF", "MODULE-COMPLIANCE");

	    }

	}

    }

    if (! smiv1) {

	for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_GROUP);

	    smiNode;

	    smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_GROUP)) {

	    if (isObjectGroup(smiNode)) {

		if (strcmp("SNMPv2-CONF", smiModule->name)) {

		    addImport("SNMPv2-CONF", "OBJECT-GROUP");

		}

	    } else if (isNotificationGroup(smiNode)) {

		if (strcmp("SNMPv2-CONF", smiModule->name)) {

		    addImport("SNMPv2-CONF", "NOTIFICATION-GROUP");

		}

	    }

	}

    }

    if (! smiv1) {

	for(smiType = smiGetFirstType(smiModule);

	    smiType; smiType = smiGetNextType(smiType)) {

	    if (smiType->description) {

		if (strcmp("SNMPv2-TC", smiModule->name)) {

		    addImport("SNMPv2-TC", "TEXTUAL-CONVENTION");

		}

		break;

	    }

	}

    }

    for (smiImport = smiGetFirstImport(smiModule); smiImport;

	 smiImport = smiGetNextImport(smiImport)) {

	if (islower((int) smiImport->name[0]) ||

	    (smiImport->module && !strcmp(smiImport->module, "SNMPv2-SMI")) ||

	    (!smiv1 && smiImport->module && !strcmp(smiImport->module, "SNMPv2-TC"))) {

	    addImport(smiImport->module, smiImport->name);

	}

    }

}

static void freeImportList(void)

{

    Import *import, *freeme;

    for (import = importList; import; ) {

	freeme = import;

	import = import->nextPtr;

	xfree(freeme);

    }

    importList = NULL;

}

static void fprint(FILE *f, char *fmt, ...)

{

    va_list ap;

    char    *s;

    char    *p;

    va_start(ap, fmt);

    current_column += smiVasprintf(&s, fmt, ap);

    va_end(ap);

    fputs(s, f);

    if ((p = strrchr(s, '\n'))) {

	current_column = strlen(p) - 1;

    }

    free(s);

}

static void fprintSegment(FILE *f, int column, char *string,

			  int length, int comment)

{

    char *format;

    if (comment) {

	format = "-- %*c%s";

	/* if (column >= 3) column -= 3; */

    } else {

	format = "%*c%s";

    }

    fprint(f, format, column, ' ', string);

    if (length) {

	fprint(f, "%*c", length - strlen(string) - column, ' ');

    }

}

static void fprintWrapped(FILE *f, int column, char *string, int comment)

{

    if ((current_column + strlen(string)) > INDENTMAX) {

	putc('\n', f);

	current_column = 0;

	fprintSegment(f, column, "", 0, comment);

    }

    fprint(f, "%s", string);

}

static void fprintMultilineString(FILE *f, const char *s, const int comment)

{

    int i, len;

    fprintSegment(f, INDENTTEXTS - 1, "\"", 0, comment);

    if (s) {

	len = strlen(s);

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

	    putc(s[i], f);

	    current_column++;

	    if (s[i] == '\n') {

		current_column = 0;

		fprintSegment(f, INDENTTEXTS, "", 0, comment);

	    }

	}

    }

    putc('\"', f);

    current_column++;

}

static void fprintMultilineString2(FILE *f, const char *s, const int comment)

{

    int i, len;

    fprintSegment(f, INDENTTEXTS2 - 1, "\"", 0, comment);

    if (s) {

	len = strlen(s);

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

	    putc(s[i], f);

	    current_column++;

	    if (s[i] == '\n') {

		current_column = 0;

		fprintSegment(f, INDENTTEXTS2, "", 0, comment);

	    }

	}

    }

    putc('\"', f);

    current_column++;

}

static char *getValueString(SmiValue *valuePtr, SmiType *typePtr)

{

    static char    s[1024];

    char           ss[9];

    int		   n;

    unsigned int   i;

    SmiNamedNumber *nn;

    SmiNode        *nodePtr;

    s[0] = 0;

    switch (valuePtr->basetype) {

    case SMI_BASETYPE_UNSIGNED32:

	sprintf(s, "%lu", valuePtr->value.unsigned32);

	break;

    case SMI_BASETYPE_INTEGER32:

	sprintf(s, "%ld", valuePtr->value.integer32);

	break;

    case SMI_BASETYPE_UNSIGNED64:

	sprintf(s, UINT64_FORMAT, valuePtr->value.unsigned64);

	break;

    case SMI_BASETYPE_INTEGER64:

	sprintf(s, INT64_FORMAT, valuePtr->value.integer64);

	break;

    case SMI_BASETYPE_FLOAT32:

    case SMI_BASETYPE_FLOAT64:

    case SMI_BASETYPE_FLOAT128:

	break;

    case SMI_BASETYPE_ENUM:

	for (nn = smiGetFirstNamedNumber(typePtr); nn;

	     nn = smiGetNextNamedNumber(nn)) {

	    if (nn->value.value.unsigned32 == valuePtr->value.unsigned32)

		break;

	}

	if (nn) {

	    sprintf(s, "%s", nn->name);

	} else {

	    sprintf(s, "%ld", valuePtr->value.integer32);

	}

	break;

    case SMI_BASETYPE_OCTETSTRING:

	for (i = 0; i < valuePtr->len; i++) {

	    if (!isprint((int)valuePtr->value.ptr[i])) break;

	}

	if (i == valuePtr->len) {

	    sprintf(s, "\"%s\"", valuePtr->value.ptr);

	} else {

            sprintf(s, "'%*s'H", 2 * valuePtr->len, " ");

            for (i=0; i < valuePtr->len; i++) {

                sprintf(ss, "%02x", valuePtr->value.ptr[i]);

                strncpy(&s[1+2*i], ss, 2);

            }

	}

	break;

    case SMI_BASETYPE_BITS:

	if (smiv1) {

            sprintf(s, "'%*s'H", 2 * valuePtr->len, " ");

            for (i=0; i < valuePtr->len; i++) {

                sprintf(ss, "%02x", valuePtr->value.ptr[i]);

                strncpy(&s[1+2*i], ss, 2);

            }

	} else {

	    sprintf(s, "{");

	    for (i = 0, n = 0; i < valuePtr->len * 8; i++) {

		if (valuePtr->value.ptr[i/8] & (1 << (7-(i%8)))) {

		    for (nn = smiGetFirstNamedNumber(typePtr); nn;

			 nn = smiGetNextNamedNumber(nn)) {

			if (nn->value.value.unsigned32 == i)

			    break;

		    }

		    if (nn) {

			if (n)

			    sprintf(&s[strlen(s)], ", ");

			n++;

			sprintf(&s[strlen(s)], "%s", nn->name);

		    }

		}

	    }

	    sprintf(&s[strlen(s)], "}");

	}

	break;

    case SMI_BASETYPE_UNKNOWN:

	break;

    case SMI_BASETYPE_POINTER:

	break;

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	nodePtr = smiGetNodeByOID(valuePtr->len, valuePtr->value.oid);

	if (nodePtr) {

	    sprintf(s, "%s", nodePtr->name);

	} else {

	    strcpy(s, "{");

	    for (i=0; i < valuePtr->len; i++) {

		if (i) strcat(s, " ");

		sprintf(&s[strlen(s)], "%u", valuePtr->value.oid[i]);

	    }

	    strcat(s, "}");

	}

	break;

    }

    return s;

}

static void fprintSubtype(FILE *f, SmiType *smiType, const int comment)

{

    SmiRange       *range;

    SmiNamedNumber *nn;

    char	   s[1024];

    int		   i, c = comment;

    if (pibtomib && ((smiType->basetype == SMI_BASETYPE_UNSIGNED64) ||

        (smiType->basetype == SMI_BASETYPE_INTEGER64))) {

        c = 1;

        fprint(f, " -- commented out by smidump\n-- ");

    }

    c = c || (smiv1 && smiType->basetype == SMI_BASETYPE_BITS);

    if ((smiType->basetype == SMI_BASETYPE_ENUM) ||

	(smiType->basetype == SMI_BASETYPE_BITS)) {

	for(i = 0, nn = smiGetFirstNamedNumber(smiType);

	    nn; i++, nn = smiGetNextNamedNumber(nn)) {

	    if (i) {

		fprint(f, ", ");

	    } else {

		if (c) {

		    fprint(f, "\n");

		    fprintSegment(f, INDENT, "", INDENTVALUE, c);

		    fprint(f, "  { ");

		} else {

		    fprint(f, " { ");

		}

	    }

	    sprintf(s, "%s(%s)", nn->name,

		    getValueString(&nn->value, smiType));

	    fprintWrapped(f, INDENTVALUE + INDENT, s, c);

	}