/*

 * dump-corba.c --

 *

 *      Operations to dump CORBA IDL and OID definitions. This is based

 *	on the JIDM Specification Translation developed by the JIDM task

 *	force, published as Open Group <URL:http://www.opengroup.org/>

 *	document C802 (ISBN 1-85912-256-6, January 2000).

 *

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

 * Copyright (c) 1999 J. Schoenwaelder, 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-corba.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>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "smidump.h"

#define  INDENT		4    /* indent factor */

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

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

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

static int current_column = 0;

static int silent = 0;

/*

 * The following list of IDL keywords is taken from the CORBA

 * 2.3.1 IDL specification section 3.2.4 (October 1999).

 */

static char *idlKeywords[] = {

    "abstract",

    "any",		"attribute",	"boolean",	"case",

    "char",		"const",	"context",	"custom",

    "default",		"double",	"enum",		"exception",

    "factory",		"FALSE",	"fixed",	"float",

    "in",		"inout",	"interface",	"long",

    "module",		"native",	"object",	"octet",

    "oneway",		"out",		"private",	"public",

    "raises",		"readonly",	"sequence",	"short",

    "string",		"struct",	"supports",	"switch",

    "TRUE",		"truncatable",	"typedef",	"unsigned",

    "union",		"valuebase",	"valuetype",	"void",

    "wchar",		"wstring",	NULL

};

/*

 * Structure used to build a list of imported types.

 */

typedef struct Import {

    char          *module;

    char          *name;

    struct Import *nextPtr;

} Import;

static Import *importList = NULL;

/*

 * Structure used to build dictionaries that translate names

 * into IDL names following the generic JIDM rules.

 */

typedef struct IdlEntry {

    char            *module;

    char            *name;

    char            *idlname;

    struct IdlEntry *nextPtr;

} IdlEntry;

static IdlEntry *idlModuleNameList = NULL;

static IdlEntry *idlNodeNameList = NULL;

static IdlEntry *idlTypeNameList = NULL;

static IdlEntry *idlVBTypeNameList = NULL;

static IdlEntry **idlNameLists[] = {

    &idlModuleNameList, &idlNodeNameList,

    &idlTypeNameList, &idlVBTypeNameList,

    NULL

};

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 char* dictFindName(IdlEntry *list, char *module, char* name)

{

    IdlEntry *p;

    for (p = list; p; p = p->nextPtr) {

	if (! strcasecmp(p->module, module)

	    && ((! p->name && ! name) || ! strcasecmp(p->name, name))) {

	    return p->idlname;

	}

    }

    return NULL;

}

static char* dictAddName(IdlEntry **listPtr, char *module, char *name)

{

    IdlEntry *p;

    char *s, *idl;

    int i;

    /*

     * Create a new IDL identifier by translating hyphens

     * to underscores.

     */

    s = name ? name : module;

    idl = xmalloc(strlen(s) + 1);

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

	idl[i] = (s[i] == '-') ? '_' : s[i];

    }

    idl[i] = 0;

    /*

     * Check for any collisions with IDL keywords or previously

     * created IDL identifiers.

     */

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

	if (! strcasecmp(idlKeywords[i], idl)) {

	    fprintf(stderr, "smidump: "

		    "`%s' (%s%s%s) collides with IDL keyword `%s'\n",

		    idl, module, name ? "::" : "", name ? name : "",

		    idlKeywords[i]);

	}

    }

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

	IdlEntry *list = *(idlNameLists[i]);

	for (p = list; p; p = p->nextPtr) {

	    if (! strcasecmp(p->idlname, idl)) {

		fprintf(stderr, "smidump: "

			"`%s' (%s%s%s) collides with `%s' (%s%s%s)\n",

			idl, module,

			name ? "::" : "", name ? name : "",

			p->idlname, p->module,

			p->name ? "::" : "", p->name ? p->name : "");

	    }

	}

    }

    /*

     * Safe the translated identifier in the dictionary.

     */

    p = xmalloc(sizeof(IdlEntry));

    p->module = xstrdup(module);

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

    p->idlname = idl;

    p->nextPtr = *listPtr;

    *listPtr = p;

    return idl;

}

static void dictFree(IdlEntry **list)

{

    IdlEntry *p, *q;

    for (p = *list; p; ) {

	q = p;

	p = p->nextPtr;

	xfree(q->module);

	if (q->name) xfree(q->name);

	xfree(q->idlname);

	xfree(q);

    }

    *list = NULL;

}

static char* getIdlModuleName(char *module)

{

    char *s;

    s = dictFindName(idlModuleNameList, module, NULL);

    if (! s) {

	s = dictAddName(&idlModuleNameList, module, NULL);

    }

    return s;

}

static char *getIdlNodeName(char *module, char *name)

{

    char *s;

    s = dictFindName(idlNodeNameList, module, name);

    if (! s) {

	s = dictAddName(&idlNodeNameList, module, name);

    }

    return s;

}

static char* getIdlTypeName(char *module, char *name)

{

    char *s, *type_name;

    type_name = xmalloc(strlen(name) + 10);

    sprintf(type_name, "%sType", name);

    type_name[0] = toupper((int) type_name[0]);

    s = dictFindName(idlTypeNameList, module, type_name);

    if (! s) {

	s = dictAddName(&idlTypeNameList, module, type_name);

    }

    xfree(type_name);

    return s;

}

static char* getIdlVBTypeName(char *module, char *name, int *isnew)

{

    char *s, *vbTypeName;

    vbTypeName = xmalloc(strlen(name) + 10);

    sprintf(vbTypeName, "%sVBType", name);

    vbTypeName[0] = toupper((int) vbTypeName[0]);

    if (isnew) {

	*isnew = 0;

    }

    s = dictFindName(idlVBTypeNameList, module, vbTypeName);

    if (! s) {

	if (isnew) {

	    *isnew = 1;

	}

	s = dictAddName(&idlVBTypeNameList, module, vbTypeName);

    }

    xfree(vbTypeName);

    return s;

}

static int current(SmiStatus status)

{

    switch (status) {

    case SMI_STATUS_CURRENT:

    case SMI_STATUS_UNKNOWN:

    case SMI_STATUS_MANDATORY:

    case SMI_STATUS_OPTIONAL:

	return 1;

    default:

	return 0;

    }

}

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 *getAccessString(SmiAccess access, int create)

{

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

	return "read-create";

    } 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 *getBaseTypeString(SmiBasetype basetype)

{

    switch(basetype) {

    case SMI_BASETYPE_UNKNOWN:

	return "ASN1_Null";

    case SMI_BASETYPE_POINTER:

	return "ASN1_Null";

    case SMI_BASETYPE_INTEGER32:

    case SMI_BASETYPE_ENUM:

	return "ASN1_Integer";

    case SMI_BASETYPE_OCTETSTRING:

    case SMI_BASETYPE_BITS:

	return "ASN1_OctetString";

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	return "ASN1_ObjectIdentifier";

    case SMI_BASETYPE_UNSIGNED32:

	return "ASN1_Unsigned";

    case SMI_BASETYPE_INTEGER64:

	return "ASN1_Integer64";

    case SMI_BASETYPE_UNSIGNED64:

	return "ASN1_Unsigned64";

    case SMI_BASETYPE_FLOAT32:

    case SMI_BASETYPE_FLOAT64:

    case SMI_BASETYPE_FLOAT128:

	return "ASN1_Real";

    }

    return NULL;

}

static char *getIdlAnyTypeName(SmiNode *smiNode, SmiType *smiType)

{

    SmiModule *smiModule;

    char *typeName;

    if (! smiType->name) {

	smiModule = smiGetNodeModule(smiNode);

	if (smiModule && strlen(smiModule->name)) {

	    typeName = getIdlTypeName(smiModule->name, smiNode->name);

	} else {

	    typeName = getBaseTypeString(smiType->basetype);

	}

    } else {

	smiModule = smiGetTypeModule(smiType);

	if (smiModule && strlen(smiModule->name)) {

	    typeName = getIdlTypeName(smiModule->name, smiType->name);

	} else {

	    typeName = getBaseTypeString(smiType->basetype);

	}

    }

    return typeName;

}

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:

	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:

	/* TODO */

	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 Import* addImport(char *module, char *name)

{

    Import **import, *newImport;

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

    newImport->module = module;

    newImport->name = name;

    newImport->nextPtr = *import;

    *import = newImport;

    return *import;

}

static void createImportList(SmiModule *smiModule)

{

    SmiNode     *smiNode;

    SmiType     *smiType;

    SmiModule   *smiTypeModule;

    SmiElement  *smiElement;

    SmiNode     *smiNodeIndex;

    SmiNodekind kind = SMI_NODEKIND_SCALAR

	 | SMI_NODEKIND_COLUMN | SMI_NODEKIND_ROW;

    for (smiNode = smiGetFirstNode(smiModule, kind);

	 smiNode;

	 smiNode = smiGetNextNode(smiNode, kind)) {

	 switch (smiNode->nodekind) {

	 case SMI_NODEKIND_ROW:

	      for (smiElement = smiGetFirstElement(smiNode); smiElement;

		   smiElement = smiGetNextElement(smiElement)) {

		   smiNodeIndex = smiGetElementNode(smiElement);

		  smiType = smiGetNodeType(smiNodeIndex);

		  if (smiType) {

		      smiTypeModule = smiGetTypeModule(smiType);

		      if (smiTypeModule &&

			  strcmp(smiTypeModule->name, smiModule->name)) {

			  if (strlen(smiTypeModule->name)) {

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

			  }

		      }

		      if (smiType->basetype == SMI_BASETYPE_INTEGER32) {

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

		      }

		  }

	      }

	      break;

	 case SMI_NODEKIND_SCALAR:

	 case SMI_NODEKIND_COLUMN:

	      smiType = smiGetNodeType(smiNode);

	      if (smiType) {

		   smiTypeModule = smiGetTypeModule(smiType);

		   if (smiTypeModule &&

		       strcmp(smiTypeModule->name, smiModule->name)) {

			if (strlen(smiTypeModule->name)) {

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

			}

		   }

		   if (smiType->basetype == SMI_BASETYPE_INTEGER32) {

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

		   }

	      }

	      break;

	}

    }

}

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)

{

    fprint(f, "%*c%s", column, ' ', string);

    if (length) {

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

    }

}

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

{

    int i, len;

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

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

	    }

	}

    }

    putc('\"', f);

    current_column++;

}

static void fprintMultiline(FILE *f, const char *s)

{

    int i, len;

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

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

	    }

	}

    }

    putc('\n', f);

    current_column++;

}

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 char* translate(char *s)

{

    int i;

    s = xstrdup(s);

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

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

    }

    return s;

}

static int isGroup(SmiNode *smiNode)

{

    SmiNode *childNode;

    for (childNode = smiGetFirstChildNode(smiNode);

	 childNode;

	 childNode = smiGetNextChildNode(childNode)) {

	if ((childNode->nodekind == SMI_NODEKIND_SCALAR

	     || childNode->nodekind == SMI_NODEKIND_TABLE)

	    && current(childNode->status)) {

	    return 1;

	}

    }

    return 0;

}

static int isCreatable(SmiNode *smiNode)

{

    SmiNode *childNode;

    if ((isGroup(smiNode) || smiNode->nodekind == SMI_NODEKIND_ROW)

	&& current(smiNode->status)) {

	for (childNode = smiGetFirstChildNode(smiNode);

	     childNode;

	     childNode = smiGetNextChildNode(childNode)) {

	    if ((childNode->nodekind == SMI_NODEKIND_SCALAR

		 || childNode->nodekind == SMI_NODEKIND_COLUMN)

		&& current(childNode->status)

		&& childNode->access == SMI_ACCESS_READ_WRITE) {

		return 1;

	    }

	}

    }

    return 0;

}

static void fprintDescription(FILE *f, SmiNode *smiNode, int indent)

{

    fprint(f, "\n");

    fprintSegment(f, indent, "/*\n", 0);

    if (smiNode->description) {

	fprintMultiline(f, smiNode->description);

    }

    if (smiNode->reference) {

	fprintSegment(f, indent, "REFERENCE:", 0);

	fprint(f, "\n");

	fprintMultilineString(f, smiNode->reference);

	fprint(f, "\n\n");

    }

    if (smiNode->units) {

	fprintSegment(f, indent, "UNITS:", 0);

	fprint(f, "\n");

	fprintMultilineString(f, smiNode->units);

	fprint(f, "\n\n");

    }

    fprintSegment(f, indent, "*/\n", 0);

}

static void fprintIndex(FILE *f, SmiNode *indexNode)

{

    SmiElement *smiElement;

    int        j;

    for (j = 0, smiElement = smiGetFirstElement(indexNode);

	 smiElement;

	 j++, smiElement = smiGetNextElement(smiElement)) {

	if (j) {

	    fprint(f, " ");

	}

	fprint(f, smiGetElementNode(smiElement)->name);

	/* TODO: non-local name if non-local */

    } /* TODO: empty? -> print error */

}

static void fprintIncludes(FILE *f, SmiModule *smiModule)

{

    Import    *import;

    char      *lastModulename = NULL;

    fprint(f, "#include <ASN1Types.idl>\n");

    fprint(f, "#include <SNMPMgmt.idl>\n");

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

	if (!lastModulename

	    || strcmp(lastModulename, import->module)) {

	    fprint(f, "#include <%s.idl>\n",

		  getIdlModuleName(import->module));

	    lastModulename = import->module;

	}

    }

    fprint(f, "\n");

}

static void fprintImportedTypedefs(FILE *f, SmiModule *smiModule)

{

    Import    *import;

    int	      cnt = 0;

    char      *idlTypeName;

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

	cnt++;

	idlTypeName = getIdlTypeName(import->module, import->name);

	fprintSegment(f, INDENT, "typedef ", 0);

	fprint(f, "%s::%s %s;\n",

	      getIdlModuleName(import->module), idlTypeName, idlTypeName);

    }

    if (cnt) {

	fprint(f, "\n");

    }

}

static void fprintModule(FILE *f, SmiModule *smiModule)

{

    SmiRevision  *smiRevision;

    SmiNode      *smiNode;

    char         *idlModuleName;

    smiNode = smiGetModuleIdentityNode(smiModule);

    if (smiNode) {

	idlModuleName = getIdlModuleName(smiModule->name);

	fprintSegment(f, INDENT, "const ", 0);

	fprint(f, "string moduleIdentity = \"%s\";\n", smiNode->name);

	fprintSegment(f, INDENT, "const ", 0);

	fprint(f, "ASN1_ObjectIdentifier %s = \"::%s::%s\";\n\n",

	      getIdlModuleName(smiNode->name),

	      idlModuleName, smiNode->name);

	if (! silent) {

	    fprintSegment(f, INDENT, "/*\n", 0);

	    if (smiModule->description) {

		fprintMultiline(f, smiModule->description);

		fprint(f, "\n");

	    }

	    smiRevision = smiGetFirstRevision(smiModule);

	    fprintSegment(f, INDENT, "LAST-UPDATED:", INDENTVALUE);

	    fprint(f, smiRevision

		  ? getTimeString(smiRevision->date) : "197001010000Z");

	    fprint(f, "\n\n");