/*

 * dump-scli.c --

 *

 *      Operations to generate MIB module stubs for the scli package.

 *

 * Copyright (c) 2001 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-scli.c 8090 2008-04-18 12:56:29Z strauss $

 */

/*

 * TODO:

 *	  - range checks for 64 bit numbers

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "smidump.h"

#include <sys/types.h>

#ifdef HAVE_REGEX_H

#include <regex.h>

#else

#define regex_t int

#define regcomp(a, b, c)	1

#define regexec(a, b, c, d, e)	0

#define regerror(a,b,c,d)	strncpy(c, "regex not supported", d)

#define regfree(a)

#endif

static char *prefix = NULL;

static char *include = NULL;

static char *exclude = NULL;

static int  sflag = 0;

static int  cflag = 0;

static int  dflag = 0;

static regex_t _incl_regex, *incl_regex = NULL;

static regex_t _excl_regex, *excl_regex = NULL;

static char *keywords_c99[] = {

    "auto",        "enum",        "restrict",    "unsigned",

    "break",       "extern",      "return",      "void",

    "case",        "float",       "short",       "volatile",

    "char",        "for",         "signed",      "while",

    "const",       "goto",        "sizeof",      "_Bool",

    "continue",    "if",          "static",      "_Complex",

    "default",     "inline",      "struct",      "_Imaginary",

    "do",          "int",         "switch",

    "double",      "long",        "typedef",

    "else",        "register",    "union",

    NULL

};

static int

isKeyword(char *m)

{

    int i;

    for (i = 0; keywords_c99[i]; i++) {

	if (strcmp(m, keywords_c99[i]) == 0) {

	    return 1;

	}

    }

    return 0;

}

static char *

getStringTime(time_t t)

{

    static char   s[27];

    struct tm	  *tm;

    tm = gmtime(&t);

    sprintf(s, "%04d-%02d-%02d %02d:%02d",

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

	    tm->tm_hour, tm->tm_min);

    return s;

}

static void

fprintCommentString(FILE *f, char *s)

{

    int i, len;

    if (s) {

	fprintf(f, " *   ");

	len = strlen(s);

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

	    fputc(s[i], f);

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

		fprintf(f, " *   ");

	    }

	}

	fputc('\n', f);

    }

}

static void

fprintTopComment(FILE *f, SmiModule *smiModule)

{

    SmiRevision *smiRevision;

    char *date;

    fprintf(f,

	    "/*	\t\t\t\t\t\t-- DO NOT EDIT --\n"

	    " * Generated by smidump version " SMI_VERSION_STRING ":\n");

    fprintf(f, " *   smidump -f scli");

    if (sflag) {

	fprintf(f, " --scli-set");

    }

    if (cflag) {

	fprintf(f, " --scli-create");

    }

    if (dflag) {

	fprintf(f, " --scli-delete");

    }

    if (prefix) {

	fprintf(f, " \\\n *     --scli-prefix='%s'", prefix);

    }

    if (include) {

	fprintf(f, " \\\n *     --scli-include='%s'", include);

    }

    if (exclude) {

	fprintf(f, " \\\n *     --scli-exclude='%s'", exclude);

    }

    fprintf(f, " %s\n *\n", smiModule->name);

    fprintf(f,

	    " * Derived from %s:\n", smiModule->name);

    fprintCommentString(f, smiModule->description);

    for (smiRevision = smiGetFirstRevision(smiModule);

	 smiRevision;

	 smiRevision = smiGetNextRevision(smiRevision)) {

	date = getStringTime(smiRevision->date);

	fprintf(f,

		" *\n"

		" * Revision %s:\n", date);

	fprintCommentString(f, smiRevision->description);

    }

#if 0

    if (smiModule->organization || smiModule->contactinfo) {

	fprintf(f, " *\n * Contact:\n");

	printCommentString(f, smiModule->organization);

	fprintf(f, " *\n");

	printCommentString(f, smiModule->contactinfo);

    }

#endif

    fprintf(f,

	    " *\n * $I" "d$\n"

	    " */\n"

	    "\n");

}

static char*

translate(char *m)

{

    char *s;

    int i;

    s = xstrdup(m);

    for (i = 0; s[i]; i++) {

	if (s[i] == '-') s[i] = '_';

    }

    while (isKeyword(s)) {

	s = xrealloc(s, strlen(s) + 2);

	strcat(s, "_");

    }

    return s;

}

static char*

translateUpper(char *m)

{

    char *s;

    int i;

    s = xstrdup(m);

    for (i = 0; s[i]; i++) {

	if (s[i] == '-') s[i] = '_';

	if (islower((int) s[i])) {

	    s[i] = toupper(s[i]);

	}

    }

    while (isKeyword(s)) {

	s = xrealloc(s, strlen(s) + 2);

	strcat(s, "_");

    }

    return s;

}

static char*

translateLower(char *m)

{

    char *s;

    int i;

    s = xstrdup(m);

    for (i = 0; s[i]; i++) {

	if (s[i] == '-') s[i] = '_';

	if (isupper((int) s[i])) {

	    s[i] = tolower(s[i]);

	}

    }

    while (isKeyword(s)) {

	s = xrealloc(s, strlen(s) + 2);

	strcat(s, "_");

    }

    return s;

}

static char*

translateFileName(char *m)

{

    char *s;

    int i;

    s = xstrdup(m);

    for (i = 0; s[i]; i++) {

	if (s[i] == '_') s[i] = '-';

	if (isupper((int) s[i])) {

	    s[i] = tolower(s[i]);

	}

    }

    return s;

}

static FILE *

createFile(char *name, char *suffix)

{

    char *fullname;

    FILE *f;

    fullname = xmalloc(strlen(name) + (suffix ? strlen(suffix) : 0) + 2);

    strcpy(fullname, name);

    if (suffix) {

        strcat(fullname, suffix);

    }

    if (!access(fullname, R_OK)) {

        fprintf(stderr, "smidump: %s already exists\n", fullname);

        xfree(fullname);

        return NULL;

    }

    f = fopen(fullname, "w");

    if (!f) {

        fprintf(stderr, "smidump: cannot open %s for writing: ", fullname);

        perror(NULL);

        xfree(fullname);

        exit(1);

    }

    xfree(fullname);

    return f;

}

static int

isGroup(SmiNode *smiNode, SmiNodekind memberkind)

{

    SmiNode *childNode;

    int status;

    if (incl_regex) {

	if (! smiNode->name) {

	    return 0;

	}

	status = regexec(incl_regex, smiNode->name, (size_t) 0, NULL, 0);

	if (status != 0) {

	    return 0;

	}

    }

    if (excl_regex) {

	if (! smiNode->name) {

	    return 0;

	}

	status = regexec(excl_regex, smiNode->name, (size_t) 0, NULL, 0);

	if (status == 0) {

	    return 0;

	}

    }

    for (childNode = smiGetFirstChildNode(smiNode);

	 childNode;

	 childNode = smiGetNextChildNode(childNode)) {

	if (childNode->nodekind & memberkind) {

	    return 1;

	}

    }

    return 0;

}

static int

isAccessible(SmiNode *groupNode)

{

    SmiNode *smiNode;

    int num = 0;

    for (smiNode = smiGetFirstChildNode(groupNode);

	 smiNode;

	 smiNode = smiGetNextChildNode(smiNode)) {

	if ((smiNode->nodekind == SMI_NODEKIND_SCALAR

	     || smiNode->nodekind == SMI_NODEKIND_COLUMN)

	    && (smiNode->access == SMI_ACCESS_READ_ONLY

		|| smiNode->access == SMI_ACCESS_READ_WRITE)) {

	    num++;

	}

    }

    return num;

}

static int

isIndex(SmiNode *groupNode, SmiNode *smiNode)

{

    SmiElement *smiElement;

    /*

     * Perhaps this test needs to be more sophisticated if you have

     * really creative cross-table indexing constructions...

     */

    for (smiElement = smiGetFirstElement(groupNode);

	 smiElement; smiElement = smiGetNextElement(smiElement)) {

	if (smiNode == smiGetElementNode(smiElement)) {

	    return 1;

	}

    }

    return 0;

}

static int

isWritable(SmiNode *treeNode, SmiNodekind nodekind)

{

    SmiNode *smiNode;

    for (smiNode = smiGetFirstChildNode(treeNode);

	 smiNode;

	 smiNode = smiGetNextChildNode(smiNode)) {

	if (smiNode->nodekind & (nodekind)

	    && (smiNode->access >= SMI_ACCESS_READ_WRITE)) {

	    break;

	}

    }

    return (smiNode != NULL);

}

static char*

getSnmpType(SmiType *smiType)

{

    struct {

	char *module;

	char *name;

	char *tag;

    } typemap[] = {

	{ "RFC1155-SMI","Counter",	"GNET_SNMP_VARBIND_TYPE_COUNTER32" },

	{ "SNMPv2-SMI",	"Counter32",	"GNET_SNMP_VARBIND_TYPE_COUNTER32" },

	{ "RFC1155-SMI","TimeTicks",	"GNET_SNMP_VARBIND_TYPE_TIMETICKS" },

	{ "SNMPv2-SMI",	"TimeTicks",	"GNET_SNMP_VARBIND_TYPE_TIMETICKS" },

	{ "RFC1155-SMI","Opaque",	"GNET_SNMP_VARBIND_TYPE_OPAQUE" },

	{ "SNMPv2-SMI",	"Opaque",	"GNET_SNMP_VARBIND_TYPE_OPAQUE" },

	{ "RFC1155-SMI","IpAddress",	"GNET_SNMP_VARBIND_TYPE_IPADDRESS" },

	{ "SNMPv2-SMI",	"IpAddress",	"GNET_SNMP_VARBIND_TYPE_IPADDRESS" },

	{ NULL, NULL, NULL }

    };

    SmiBasetype basetype = smiType->basetype;

    do {

	int i;

	for (i = 0; typemap[i].name; i++) {

	    if (smiType->name

		&& (strcmp(smiType->name, typemap[i].name) == 0)) {

		return typemap[i].tag;

	    }

	}

    } while ((smiType = smiGetParentType(smiType)));

    switch (basetype) {

    case SMI_BASETYPE_INTEGER32:

    case SMI_BASETYPE_ENUM:

	return "GNET_SNMP_VARBIND_TYPE_INTEGER32";

    case SMI_BASETYPE_UNSIGNED32:

	return "GNET_SNMP_VARBIND_TYPE_UNSIGNED32";

    case SMI_BASETYPE_INTEGER64:

	return NULL;

    case SMI_BASETYPE_UNSIGNED64:

	return "GNET_SNMP_VARBIND_TYPE_COUNTER64";

    case SMI_BASETYPE_OCTETSTRING:

	return "GNET_SNMP_VARBIND_TYPE_OCTETSTRING";

    case SMI_BASETYPE_BITS:

	return "GNET_SNMP_VARBIND_TYPE_OCTETSTRING";

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	return "GNET_SNMP_VARBIND_TYPE_OBJECTID";

    case SMI_BASETYPE_FLOAT32:

    case SMI_BASETYPE_FLOAT64:

    case SMI_BASETYPE_FLOAT128:

	return NULL;

    case SMI_BASETYPE_UNKNOWN:

	return NULL;

    case SMI_BASETYPE_POINTER:

	return NULL;

    }

    return NULL;

}

typedef void	(*ForEachIndexFunc)	(FILE *f, SmiNode *groupNode, SmiNode *smiNode, int flags, int maxlen, char *name);

/*

 * Check whether we have duplicate nodes in the INDEX.  If yes,

 * generate a unique name.

 */

static char*

getIndexName(SmiNode *indexNode, SmiNode *iNode, SmiElement *smiElement)

{

    SmiElement *se;

    SmiNode *sn;

    int n = 0, m = 0, tail = 0;

    char *name;

    for (se = smiGetFirstElement(indexNode);

	 se; se = smiGetNextElement(se)) {

	sn = smiGetElementNode(se);

	if (strcmp(sn->name, iNode->name) == 0) {

	    n++;

	    if (! tail) m++;

	}

	if (se == smiElement) tail = 1;

    }

    if (n > 1) {

	smiAsprintf(&name, "%s%d", iNode->name, m);

    } else {

	name = xstrdup(iNode->name);

    }

    return name;

}

static void

foreachIndexDo(FILE *f, SmiNode *smiNode, ForEachIndexFunc func,

	       int flags, int maxlen)

{

    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) {

		char *name = getIndexName(indexNode, iNode, smiElement);

		(func) (f, smiNode, iNode, flags, maxlen, name);

		if (name) xfree(name);

	    }

	}

    }

}

static void

printIndexParamsFunc(FILE *f, SmiNode *smiNode, SmiNode *iNode,

		     int flags, int maxlen, char *name)

{

    SmiType *iType;

    char *cName;

    unsigned minSize, maxSize;

    iType = smiGetNodeType(iNode);

    if (! iType) {

	return;

    }

    cName = translate(name ? name : iNode->name);

    switch (iType->basetype) {

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	maxSize = smiGetMaxSize(iType);

	minSize = smiGetMinSize(iType);

	fprintf(f, ", %s%s", flags ? "guint32 *" : "", cName);

	if (minSize != maxSize) {

	    fprintf(f, ", %s_%sLength",

		    flags ? "guint16 " : "", cName);

	}

	break;

    case SMI_BASETYPE_OCTETSTRING:

    case SMI_BASETYPE_BITS:

	maxSize = smiGetMaxSize(iType);

	minSize = smiGetMinSize(iType);

	fprintf(f, ", %s%s", flags ? "guchar *" : "", cName);

	if (minSize != maxSize) {

	    fprintf(f, ", %s_%sLength",

		    flags ? "guint16 " : "", cName);

	}

	break;

    case SMI_BASETYPE_ENUM:

    case SMI_BASETYPE_INTEGER32:

	fprintf(f, ", %s%s", flags ? "gint32 " : "", cName);

	break;

    case SMI_BASETYPE_UNSIGNED32:

	fprintf(f, ", %s%s", flags ? "guint32 " : "", cName);

	break;

    default:

	fprintf(f, "/* ?? %s */", cName);

	break;

    }

    xfree(cName);

}

static void

printIndexParamsPassFunc(FILE *f, SmiNode *smiNode, SmiNode *iNode,

			 int flags, int maxlen, char *name)

{

    SmiType *iType;

    char *cName, *gName;

    unsigned minSize, maxSize;

    iType = smiGetNodeType(iNode);

    if (! iType) {

	return;

    }

    gName = translate(smiNode->name);

    cName = translate(iNode->name);

    fprintf(f, ", %s->%s", gName, cName);

    switch (iType->basetype) {

    case SMI_BASETYPE_BITS:

    case SMI_BASETYPE_OCTETSTRING:

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	maxSize = smiGetMaxSize(iType);

	minSize = smiGetMinSize(iType);

	if (minSize != maxSize) {

	    fprintf(f, ", %s->_%sLength", gName, cName);

	}

	break;

    default:

	break;

    }

    xfree(cName);

    xfree(gName);

}

static void

printIndexAssignmentFunc(FILE *f, SmiNode *smiNode, SmiNode *iNode,

			 int flags, int maxlen, char *name)

{

    SmiType *iType;

    char *cName, *gName, *dName, *dModuleName;

    unsigned minSize, maxSize;

    iType = smiGetNodeType(iNode);

    if (! iType) {

	return;

    }

    gName = translate(smiNode->name);

    cName = translate(iNode->name);

    dName = translateUpper(iNode->name);

    dModuleName = translateUpper(smiGetNodeModule(iNode)->name);

    switch (iType->basetype) {

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	fprintf(f, "    memcpy(%s->%s, %s, _%sLength * sizeof(guint32));\n",

	    gName, cName, cName, cName);

	break;

    case SMI_BASETYPE_OCTETSTRING:

    case SMI_BASETYPE_BITS:

	maxSize = smiGetMaxSize(iType);

	minSize = smiGetMinSize(iType);

	if (minSize != maxSize) {

	    fprintf(f, "    memcpy(%s->%s, %s, _%sLength);\n",

		    gName, cName, cName, cName);

	} else {

	    fprintf(f, "    memcpy(%s->%s, %s, %s_%sLENGTH);\n",

		    gName, cName, cName, dModuleName, dName);

	}

	break;

    case SMI_BASETYPE_ENUM:

    case SMI_BASETYPE_INTEGER32:

    case SMI_BASETYPE_UNSIGNED32:

	fprintf(f, "    %s->%s = %s;\n",

		gName, cName, cName);

	break;

    default:

	fprintf(f, "    /* ?? %s */\n", cName);

	break;

    }

    xfree(dModuleName);

    xfree(dName);

    xfree(cName);

    xfree(gName);

}

static void

printHeaderEnumeration(FILE *f, SmiModule *smiModule,

		       SmiNode * smiNode, SmiType *smiType)

{

    SmiNamedNumber *nn;

    char *cName, *cPrefix;

    char *dName, *dModuleName;

    char *name;

    int len;

    if (smiType && smiType->name) {

	name = smiType->name;

    } else if (smiNode && smiNode->name) {

	name = smiNode->name;

    } else {

	return;

    }

    cPrefix = prefix ? xstrdup(prefix) : translateLower(smiModule->name);

    dModuleName = translateUpper(smiModule->name);

    cName = translate(name);

    dName = translateUpper(name);

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

	 nn = smiGetNextNamedNumber(nn)) {

	if (len < strlen(nn->name)) {

	    len = strlen(nn->name);

	}

    }

    for (nn = smiGetFirstNamedNumber(smiType); nn;

		 nn = smiGetNextNamedNumber(nn)) {

	char *dEnum = translateUpper(nn->name);

	fprintf(f, "#define %s_%s_%-*s %d\n",

		dModuleName, dName, len, dEnum,

		(int) nn->value.value.integer32);

	xfree(dEnum);

    }

    fprintf(f, "\nextern GNetSnmpEnum const %s_enums_%s[];\n\n",

	    cPrefix, cName);

    xfree(dName);

    xfree(cName);

    xfree(dModuleName);

    xfree(cPrefix);

}

static void

printHeaderEnumerations(FILE *f, SmiModule *smiModule)

{

    SmiNode  *smiNode, *parentNode;

    SmiType  *smiType;

    int      cnt = 0;

    const unsigned int groupkind = SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN;

    const char *header =

	"/*\n"

	" * Tables to map enumerations to strings and vice versa.\n"

	" */\n"

	"\n";

    for (smiNode = smiGetFirstNode(smiModule, groupkind);

	 smiNode;

	 smiNode = smiGetNextNode(smiNode, groupkind)) {

	parentNode = smiGetParentNode(smiNode);

	if (! parentNode || ! isGroup(parentNode, groupkind)) {

	    continue;

	}

	smiType = smiGetNodeType(smiNode);

	if (smiType && !smiType->name

	    && smiType->basetype == SMI_BASETYPE_ENUM

	    && smiGetTypeModule(smiType) == smiModule) {

	    if (! cnt) {

		fputs(header, f);

	    }

	    cnt++;

	    printHeaderEnumeration(f, smiModule, smiNode, smiType);

	}

    }

    for (smiType = smiGetFirstType(smiModule);

	 smiType;

	 smiType = smiGetNextType(smiType)) {

	if (smiType->basetype == SMI_BASETYPE_ENUM

	    && smiGetTypeModule(smiType) == smiModule) {

	    if (! cnt) {

		fputs(header, f);

	    }

	    cnt++;

	    printHeaderEnumeration(f, smiModule, NULL, smiType);

	}

    }

    if (cnt) {

	fprintf(f, "\n");

    }

}

static void

printHeaderIdentities(FILE *f, SmiModule *smiModule)

{

    SmiNode      *smiNode, *moduleIdentityNode, *parentNode;

    int          cnt = 0;

    unsigned int i;

    char         *dName, *dModuleName;

    char         *cModuleName;

    moduleIdentityNode = smiGetModuleIdentityNode(smiModule);

    dModuleName = translateUpper(smiModule->name);

    for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NODE);

	 smiNode;

	 smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NODE)) {

	parentNode = smiGetParentNode(smiNode);

	if (! parentNode || ! isGroup(parentNode, SMI_NODEKIND_NODE)) {

	    continue;

	}

	if (smiNode->status == SMI_STATUS_UNKNOWN) {

	    continue;

	}

	if (smiNode == moduleIdentityNode) {

	    continue;

	}

	if (! cnt) {

	    fprintf(f,

		    "/*\n"

		    " * Tables to map identities to strings and vice versa.\n"

		    " */\n"

		    "\n");

	}

	cnt++;

	dName = translateUpper(smiNode->name);

	fprintf(f, "#define %s_%s\t", dModuleName, dName);

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

	    fprintf(f, "%s%u", i ? "," : "", smiNode->oid[i]);

	}

	fprintf(f, "\n");

	xfree(dName);

    }

    if (cnt) {

	cModuleName = translateLower(smiModule->name);

	fprintf(f,

		"\n"

		"extern GNetSnmpIdentity const %s_identities[];\n"

		"\n",

		cModuleName);

	xfree(cModuleName);

    }

    xfree(dModuleName);

}

static void

printHeaderNotifications(FILE *f, SmiModule *smiModule)

{

    SmiNode      *smiNode;

    int          cnt = 0;

    unsigned int i;

    char         *dName, *dModuleName;

    char         *cModuleName;

    dModuleName = translateUpper(smiModule->name);

    for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NOTIFICATION);

	 smiNode;

	 smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NOTIFICATION)) {

	if (smiNode->status == SMI_STATUS_UNKNOWN) {

	    continue;

	}

	if (! cnt) {

	    fprintf(f,

		    "/*\n"

		    " * Tables to map notifications to strings and vice versa.\n"

		    " */\n"

		    "\n");

	}

	cnt++;

	dName = translateUpper(smiNode->name);

	fprintf(f, "#define %s_%s\t", dModuleName, dName);

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

	    fprintf(f, "%s%u", i ? "," : "", smiNode->oid[i]);

	}

	fprintf(f, "\n");

	xfree(dName);

    }

    if (cnt) {

	cModuleName = translateLower(smiModule->name);

	fprintf(f,

		"\n"

		"extern GNetSnmpIdentity const %s_notifications[];\n"

		"\n",

		cModuleName);

	xfree(cModuleName);

    }

    xfree(dModuleName);

}