static void
incrRowStatusCounter(SmiNode *rowNode)
{
SmiNode *smiNode;
SmiType *smiType;
SmiModule *smiModule;
for (smiNode = smiGetFirstChildNode(rowNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
smiType = smiGetNodeType(smiNode);
if (smiType && smiType->name) {
smiModule = smiGetTypeModule(smiType);
if (smiModule && smiModule->name
&& strcmp(smiType->name, "RowStatus") == 0
&& strcmp(smiModule->name, "SNMPv2-TC") == 0) {
break;
}
}
}
if (smiNode) {
#if 0
fprintf(stderr, "** %s\t%s\t%s\n", rowNode->name,
smiNode->name, smiType->name);
/* xxx count rows indexed by ifIndex, InterfaceIndex, InterfaceIndexOrZero, ... */
#endif
}
}
static void
complexity(FILE *f, SmiNode *row, SmiNode *col, void *data)
{
int *cmplx = (int *) data;
SmiType *smiType;
unsigned long min, max;
smiType = smiGetNodeType(col);
if (! smiType) {
return;
}
switch (smiType->basetype) {
case SMI_BASETYPE_INTEGER32:
case SMI_BASETYPE_UNSIGNED32:
case SMI_BASETYPE_ENUM:
*cmplx += 1;
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_OBJECTIDENTIFIER:
case SMI_BASETYPE_BITS:
*cmplx += 2;
min = getMinSize(smiType);
max = getMaxSize(smiType);
if (min != max) {
*cmplx += 1;
}
break;
default: /* ignore everything else */
break;
}
}
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
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;
}
}
}
static char *getTypeName(SmiNode *smiNode)
{
char *type;
SmiType *smiType, *parentType;
smiType = smiGetNodeType(smiNode);
if (!smiType || smiNode->nodekind == SMI_NODEKIND_TABLE)
return NULL;
if (smiType->decl == SMI_DECL_IMPLICIT_TYPE) {
parentType = smiGetParentType(smiType);
if (!parentType)
return NULL;
smiType = parentType;
}
type = xstrdup(smiType->name);
return type;
}
static void createImportList(SmiModule *smiModule)
{
SmiNode *smiNode;
SmiType *smiType;
SmiModule *smiTypeModule;
SmiNodekind kind = SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN;
SmiImport *smiImport;
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) {
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");
}
}
}
for (smiImport = smiGetFirstImport(smiModule); smiImport;
smiImport = smiGetNextImport(smiImport)) {
if (islower((int) smiImport->name[0]) ||
(smiImport->module && !strcmp(smiImport->module, "SNMPv2-SMI")) ||
(smiImport->module && !strcmp(smiImport->module, "SNMPv2-TC"))) {
addImport(smiImport->module, smiImport->name);
}
}
}
static void printCreateTable(SmiNode *groupNode)
{
SmiNode *smiNode;
SmiType *smiType;
char *sqlTableName;
int i;
if (groupNode->nodekind == SMI_NODEKIND_ROW) {
sqlTableName = translate(smiGetParentNode(groupNode)->name);
} else {
sqlTableName = translate(groupNode->name);
}
printf("create table %s (\n", sqlTableName);
xfree(sqlTableName);
for (smiNode = smiGetFirstChildNode(groupNode), i = 0;
smiNode;
smiNode = smiGetNextChildNode(smiNode), i++) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
#if 0
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)
#endif
) {
smiType = smiGetNodeType(smiNode);
if (smiType && ! smiType->name) {
smiType = smiGetParentType(smiType);
}
if (i) {
printf(",\n");
}
if (smiType) {
printf(" %s %s", smiNode->name, smiType->name);
}
}
}
printf("\n);\n\n");
}
static void printClass(int *x, int *y, SmiNode *smiNode)
{
SmiNode *childNode;
SmiType *smiType;
char string[4096];
*y += Y_OFFSET;
printString(*x, *y, 0, smiNode->name);
for(childNode = smiGetFirstChildNode(smiNode);
childNode;
childNode = smiGetNextChildNode(childNode)) {
if (childNode->nodekind == SMI_NODEKIND_SCALAR
|| childNode->nodekind == SMI_NODEKIND_COLUMN) {
if (childNode->status != SMI_STATUS_OBSOLETE) {
smiType = smiGetNodeType(childNode);
*y += Y_OFFSET;
sprintf(string, "%s : %s", childNode->name, smiType->name);
printString(*x + X_INDENT, *y, 0, string);
}
}
}
*y += Y_OFFSET;
}
static void printAgtDefinesGroup(FILE *f, SmiNode *groupNode, int cnt)
{
char *cName, *cGroupName;
SmiNode *smiNode;
SmiType *smiType;
int num = 0;
unsigned int i;
if (cnt == 1) {
fprintf(f,
"/*\n"
" * Definitions of tags that are used internally to read/write\n"
" * the selected object type. These tags should be unique.\n"
" */\n\n");
}
cGroupName = translate(groupNode->name);
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)) {
num++;
cName = translateUpper(smiNode->name);
fprintf(f, "#define %-32s %d\n", cName,
smiNode->oid[smiNode->oidlen-1]);
xfree(cName);
}
}
fprintf(f, "\n");
if (num) {
fprintf(f, "static oid %s_base[] = {", cGroupName);
for (i = 0; i < groupNode->oidlen; i++) {
fprintf(f, "%s%d", i ? ", " : "", groupNode->oid[i]);
}
fprintf(f, "};\n\n");
fprintf(f, "struct variable %s_variables[] = {\n", cGroupName);
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)) {
smiType = smiGetNodeType(smiNode);
if (!smiType) {
continue;
}
cName = translateUpper(smiNode->name);
fprintf(f, " { %s, %s, %s, read_%s_stub, %d, {%d} },\n",
cName, getBaseTypeString(smiType->basetype),
getAccessString(smiNode->access),
cGroupName, 1, smiNode->oid[smiNode->oidlen-1]);
xfree(cName);
}
}
fprintf(f, "};\n\n");
}
xfree(cGroupName);
}
static void
append_index(SmiSubid *oid, unsigned int *oidlen,
SmiNode *indexNode, len_type flags)
{
SmiInteger32 int32 = 0;
SmiUnsigned32 uint32 = 0;
SmiType *indexType;
SmiModule *indexModule;
int i, len = 0;
if (! indexNode) return;
indexType = smiGetNodeType(indexNode);
if (! indexType) return;
indexModule = smiGetTypeModule(indexType);
switch (indexType->basetype) {
case SMI_BASETYPE_OBJECTIDENTIFIER:
switch (flags) {
case len_max:
len = 128 - *oidlen;
if (indexNode->implied) len--;
break;
case len_mean:
len = 16;
break;
case len_min:
len = 2;
break;
}
if (! indexNode->implied && *oidlen < 128) {
oid[(*oidlen)++] = len;
}
for (i = 0; i < len && *oidlen < 128; i++) {
switch (flags) {
case len_max:
if (i == 0) {
oid[(*oidlen)++] = 2;
} else {
oid[(*oidlen)++] = 4294967295UL;
}
break;
case len_mean:
oid[(*oidlen)++] = i + 1;
break;
case len_min:
oid[(*oidlen)++] = 0;
break;
}
}
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_BITS:
switch (flags) {
case len_max:
len = smiGetMaxSize(indexType);
break;
case len_mean:
len = (smiGetMaxSize(indexType) + smiGetMinSize(indexType) / 2);
break;
case len_min:
len = smiGetMinSize(indexType);
break;
}
if (indexModule && indexModule->name && indexType->name) {
int i;
for (i = 0; specialTypes[i].module; i++) {
if (strcmp(specialTypes[i].module, indexModule->name) == 0
&& (strcmp(specialTypes[i].name, indexType->name) == 0)) {
break;
}
}
if (specialTypes[i].module) {
switch (flags) {
case len_max:
len = specialTypes[i].max;
break;
case len_mean:
len = specialTypes[i].mean;
break;
case len_min:
len = specialTypes[i].min;
break;
}
}
}
if (! indexNode->implied && *oidlen < 128) {
oid[(*oidlen)++] = len;
}
for (i = 0; i < len && *oidlen < 128; i++) {
switch (flags) {
case len_max:
oid[(*oidlen)++] = 255;
break;
case len_mean:
if (i == 0) {
oid[(*oidlen)++] = 1;
} else {
oid[(*oidlen)++] = (i%2) ? 85 : 170;
}
break;
case len_min:
oid[(*oidlen)++] = 0;
break;
}
}
break;
case SMI_BASETYPE_ENUM:
switch (flags) {
case len_max:
int32 = getAbsMaxEnum(indexType);
break;
case len_mean:
int32 = (getAbsMaxEnum(indexType) - getAbsMinEnum(indexType)) / 2;
break;
case len_min:
int32 = getAbsMinEnum(indexType);
break;
}
if (*oidlen < 128) {
oid[(*oidlen)++] = int32;
}
break;
case SMI_BASETYPE_INTEGER32:
switch (flags) {
case len_max:
int32 = getAbsMaxInteger32(indexType);
break;
case len_mean:
int32 = (getAbsMaxInteger32(indexType)
+ getAbsMinInteger32(indexType)) / 2;
break;
case len_min:
int32 = getAbsMinInteger32(indexType);
break;
}
if (*oidlen < 128) {
oid[(*oidlen)++] = int32;
}
break;
case SMI_BASETYPE_UNSIGNED32:
switch (flags) {
case len_max:
uint32 = getMaxUnsigned32(indexType);
break;
case len_mean:
uint32 = (getMaxUnsigned32(indexType)
+ getMinUnsigned32(indexType)) / 2;
break;
case len_min:
uint32 = getMinUnsigned32(indexType);
break;
}
if (*oidlen < 128) {
oid[(*oidlen)++] = uint32;
}
break;
case SMI_BASETYPE_UNKNOWN:
case SMI_BASETYPE_INTEGER64:
case SMI_BASETYPE_UNSIGNED64:
case SMI_BASETYPE_FLOAT32:
case SMI_BASETYPE_FLOAT64:
case SMI_BASETYPE_FLOAT128:
case SMI_BASETYPE_POINTER:
/* should never really get here */
break;
}
}
static int
ber_len_varbind(SmiNode *smiNode, len_type flags)
{
SmiNode *row;
SmiSubid oid[128];
unsigned int oidlen = sizeof(oid)/sizeof(oid[0]);
int len = 0;
#ifdef DUMP_OID
int x;
#endif
switch (smiNode->nodekind) {
case SMI_NODEKIND_SCALAR:
for (oidlen = 0; oidlen < smiNode->oidlen; oidlen++) {
oid[oidlen] = smiNode->oid[oidlen];
}
oid[oidlen++] = 0;
break;
case SMI_NODEKIND_COLUMN:
for (oidlen = 0; oidlen < smiNode->oidlen; oidlen++) {
oid[oidlen] = smiNode->oid[oidlen];
}
row = smiGetParentNode(smiNode);
if (row) {
SmiNode *indexNode = NULL, *iNode;
SmiElement *smiElement;
switch (row->indexkind) {
case SMI_INDEX_INDEX:
case SMI_INDEX_REORDER:
indexNode = row;
break;
case SMI_INDEX_EXPAND: /* TODO: we have to do more work here! */
break;
case SMI_INDEX_AUGMENT:
case SMI_INDEX_SPARSE:
indexNode = smiGetRelatedNode(row);
break;
case SMI_INDEX_UNKNOWN:
break;
}
if (indexNode) {
for (smiElement = smiGetFirstElement(indexNode);
smiElement;
smiElement = smiGetNextElement(smiElement)) {
iNode = smiGetElementNode(smiElement);
append_index(oid, &oidlen, iNode, flags);
}
}
}
break;
default:
return 0;
}
#ifdef DUMP_OID
fprintf(stderr, "%-32s\t", smiNode->name);
for (x = 0; x < oidlen; x++) {
fprintf(stderr, ".%u", oid[x]);
}
fprintf(stderr, "\n");
#endif
len += ber_len_oid(oid, oidlen);
len += ber_len_val(smiGetNodeType(smiNode), flags);
len += ber_len_length(len) + 1;
return len;
}
static void
dumpSizeOfCreatePDU(FILE *f, SmiModule *smiModule, SmiNode *smiNode,
int ignoreDefaultColumns)
{
SmiNode *child;
SmiType *childType;
SmiModule *childTypeModule;
int worst = 0;
int best = 0;
int avg = 0;
int b, w, a, n = 0;
int isRowStatus;
for (child = smiGetFirstChildNode(smiNode);
child;
child = smiGetNextChildNode(child)) {
if (child->access == SMI_ACCESS_READ_WRITE) {
/* Ensure RowStatus columns are present even if they
* have a default value. */
childType = smiGetNodeType(child);
childTypeModule = childType
? smiGetTypeModule(childType) : NULL;
isRowStatus
= (childType && childType->name
&& childTypeModule && childTypeModule->name)
? (strcmp(childType->name, "RowStatus") == 0
&& strcmp(childTypeModule->name, "SNMPv2-TC") == 0)
: 0;
/* xxx at least one PDU must be present xxx */
if (ignoreDefaultColumns
&& child->value.basetype != SMI_BASETYPE_UNKNOWN
&& !isRowStatus) {
continue;
}
b = ber_len_varbind(child, len_min);
a = ber_len_varbind(child, len_mean);
w = ber_len_varbind(child, len_max);
#if 0
fprintf(f, " %-32s\t[%d..%d] | %d\n", child->name, b, w, a);
#endif
best += b, worst += w, avg += a, n++;
}
}
/* varbind list sequence length and tag */
best += ber_len_length(best) + 1;
avg += ber_len_length(avg) + 1;
worst += ber_len_length(worst) + 1;
/* request-id as defined in RFC 3416 */
best += ber_len_int32(0);
avg += ber_len_int32(1073741824);
worst += ber_len_int32(-214783648);
/* error-status as defined in RFC 3416 */
best += ber_len_int32(0);
avg += ber_len_int32(0);
worst += ber_len_int32(18);
/* error-index as defined in RFC 3416 */
best += ber_len_int32(0);
avg += ber_len_int32(0);
worst += ber_len_int32(n-1);
/* PDU sequence length and tag */
best += ber_len_length(best) + 1;
avg += ber_len_length(avg) + 1;
worst += ber_len_length(worst) + 1;
fprintf(f, "%-23s %-23s \t%d\t[%d..%d]\n", smiModule->name, smiNode->name,
avg, best, worst);
}
static void printMgrGetScalarAssignement(FILE *f, SmiNode *groupNode)
{
SmiNode *smiNode;
SmiType *smiType;
char *cGroupName, *cName;
unsigned maxSize, minSize;
cGroupName = translate(groupNode->name);
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)) {
smiType = smiGetNodeType(smiNode);
if (!smiType) {
continue;
}
cName = translate(smiNode->name);
fprintf(f,
" if (vars->name_length > sizeof(%s)/sizeof(oid)\n"
" && memcmp(vars->name, %s, sizeof(%s)) == 0) {\n",
cName, cName, cName);
switch (smiType->basetype) {
case SMI_BASETYPE_INTEGER32:
case SMI_BASETYPE_UNSIGNED32:
case SMI_BASETYPE_ENUM:
fprintf(f,
" (*%s)->__%s = *vars->val.integer;\n"
" (*%s)->%s = &((*%s)->__%s);\n",
cGroupName, cName,
cGroupName, cName, cGroupName, cName);
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_BITS:
maxSize = smiGetMaxSize(smiType);
minSize = smiGetMinSize(smiType);
fprintf(f,
" memcpy((*%s)->__%s, vars->val.string, vars->val_len);\n",
cGroupName, cName);
if (minSize != maxSize) {
fprintf(f,
" (*%s)->_%sLength = vars->val_len;\n",
cGroupName, cName);
}
fprintf(f,
" (*%s)->%s = (*%s)->__%s;\n",
cGroupName, cName, cGroupName, cName);
break;
case SMI_BASETYPE_OBJECTIDENTIFIER:
break;
default:
break;
}
fprintf(f,
" }\n");
xfree(cName);
}
}
xfree(cGroupName);
}
static void printAgtReadMethod(FILE *f, SmiNode *groupNode)
{
SmiNode *smiNode;
SmiType *smiType;
char *cName, *sName, *lName;
sName = translate(groupNode->name);
fprintf(f,
"static unsigned char *\nread_%s_stub(struct variable *vp,\n"
" oid *name,\n"
" size_t *length,\n"
" int exact,\n"
" size_t *var_len,\n"
" WriteMethod **write_method)\n"
"{\n", sName);
fprintf(f, " static %s_t %s;\n\n", sName, sName);
smiNode = smiGetFirstChildNode(groupNode);
if (smiNode && smiNode->nodekind == SMI_NODEKIND_SCALAR) {
fprintf(f,
" /* check whether the instance identifier is valid */\n"
"\n"
" if (header_generic(vp, name, length, exact, var_len,\n"
" write_method) == MATCH_FAILED) {\n"
" return NULL;\n"
" }\n"
"\n");
}
fprintf(f,
" /* call the user supplied function to retrieve values */\n"
"\n"
" read_%s(&%s);\n"
"\n", sName, sName);
fprintf(f,
" /* return the current value of the variable */\n"
"\n"
" switch (vp->magic) {\n"
"\n");
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)) {
cName = translateUpper(smiNode->name);
lName = translate(smiNode->name);
smiType = smiGetNodeType(smiNode);
if (! smiType) {
continue;
}
fprintf(f, " case %s:\n", cName);
switch (smiType->basetype) {
case SMI_BASETYPE_OBJECTIDENTIFIER:
fprintf(f,
" *var_len = %s._%sLength;\n"
" return (unsigned char *) %s.%s;\n",
sName, lName, sName, lName);
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_BITS:
fprintf(f,
" *var_len = %s._%sLength;\n"
" return (unsigned char *) %s.%s;\n",
sName, lName, sName, lName);
break;
case SMI_BASETYPE_ENUM:
case SMI_BASETYPE_INTEGER32:
case SMI_BASETYPE_UNSIGNED32:
fprintf(f,
" return (unsigned char *) &%s.%s;\n",
sName, lName);
break;
default:
fprintf(f,
" /* add code to return the value here */\n");
}
fprintf(f, "\n");
xfree(cName);
xfree(lName);
}
}
fprintf(f,
" default:\n"
" ERROR_MSG(\"\");\n"
" }\n"
"\n"
" return NULL;\n"
"}\n"
"\n");
xfree(sName);
}
static void fprintObjects(FILE *f, SmiModule *smiModule)
{
int i, j;
SmiNode *smiNode, *relatedNode;
SmiElement *smiElement;
SmiType *smiType;
int indent = 0;
int lastindent = -1;
char *s = NULL;
SmiNodekind nodekinds;
nodekinds = SMI_NODEKIND_NODE | SMI_NODEKIND_TABLE |
SMI_NODEKIND_ROW | SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR |
SMI_NODEKIND_CAPABILITIES;
for(i = 0, smiNode = smiGetFirstNode(smiModule, nodekinds);
smiNode; smiNode = smiGetNextNode(smiNode, nodekinds)) {
if (smiNode->nodekind == SMI_NODEKIND_NODE) {
indent = 0;
s = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_CAPABILITIES) {
indent = 0;
s = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_TABLE) {
indent = 0;
s = "table";
} else if (smiNode->nodekind == SMI_NODEKIND_ROW) {
indent = 1;
s = "row";
} else if (smiNode->nodekind == SMI_NODEKIND_COLUMN) {
indent = 2;
s = "column";
} else if (smiNode->nodekind == SMI_NODEKIND_SCALAR) {
indent = 0;
s = "scalar";
}
if (!i && !silent) {
fprint(f, "//\n// OBJECT DEFINITIONS\n//\n\n");
}
for (j = lastindent; j >= indent; j--) {
fprintSegment(f, (1 + j) * INDENT, "", 0);
fprint(f, "};\n");
}
fprint(f, "\n");
lastindent = indent;
if (smiNode->nodekind == SMI_NODEKIND_CAPABILITIES) {
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "-- This has been an SMIv2 AGENT-CAPABILITIES node:\n");
}
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "%s %s {\n", s, smiNode->name);
if (smiNode->oid) {
fprintSegment(f, (2 + indent) * INDENT, "oid", INDENTVALUE);
fprint(f, "%s;\n", getOidString(smiNode, 0));
}
smiType = smiGetNodeType(smiNode);
if (smiType && (smiType->basetype != SMI_BASETYPE_UNKNOWN)) {
fprintSegment(f, (2 + indent) * INDENT, "type", INDENTVALUE);
if (!smiType->name) {
/*
* an implicitly restricted type.
*/
fprint(f, "%s", getTypeString(smiType->basetype,
smiGetParentType(smiType)));
fprintSubtype(f, smiType);
fprint(f, ";\n");
} else {
fprint(f, "%s;\n",
getTypeString(smiType->basetype, smiType));
}
}
if ((smiNode->nodekind != SMI_NODEKIND_TABLE) &&
(smiNode->nodekind != SMI_NODEKIND_ROW) &&
(smiNode->nodekind != SMI_NODEKIND_CAPABILITIES) &&
(smiNode->nodekind != SMI_NODEKIND_NODE)) {
if (smiNode->access != SMI_ACCESS_UNKNOWN) {
fprintSegment(f, (2 + indent) * INDENT, "access", INDENTVALUE);
fprint(f, "%s;\n", getAccessString(smiNode->access));
}
}
relatedNode = smiGetRelatedNode(smiNode);
switch (smiNode->indexkind) {
case SMI_INDEX_INDEX:
if (smiNode->implied) {
fprintSegment(f, (2 + indent) * INDENT, "index implied",
INDENTVALUE);
} else {
fprintSegment(f, (2 + indent) * INDENT, "index", INDENTVALUE);
}
fprint(f, "(");
for (j = 0, smiElement = smiGetFirstElement(smiNode); smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
break;
case SMI_INDEX_AUGMENT:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "augments",
INDENTVALUE);
fprint(f, "%s;\n", relatedNode->name);
/* TODO: non-local name if non-local */
} /* TODO: else print error */
break;
case SMI_INDEX_REORDER:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "", 0);
fprint(f, "reorders %s", relatedNode->name);
/* TODO: non-local name if non-local */
if (smiNode->implied) {
fprint(f, " implied");
}
fprint(f, " (");
for (j = 0, smiElement = smiGetFirstElement(smiNode);
smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
} /* TODO: else print error */
break;
case SMI_INDEX_SPARSE:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "sparse", INDENTVALUE);
fprint(f, "%s;\n", relatedNode->name);
/* TODO: non-local name if non-local */
} /* TODO: else print error */
break;
case SMI_INDEX_EXPAND:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "", 0);
fprint(f, "expands %s", relatedNode->name);
/* TODO: non-local name if non-local */
if (smiNode->implied) {
fprint(f, " implied");
}
fprint(f, " (");
for (j = 0, smiElement = smiGetFirstElement(smiNode);
smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
} /* TODO: else print error */
break;
case SMI_INDEX_UNKNOWN:
break;
}
if (smiNode->create) {
fprintSegment(f, (2 + indent) * INDENT, "create", INDENTVALUE);
/* TODO: create list */
fprint(f, ";\n");
}
if (smiNode->value.basetype != SMI_BASETYPE_UNKNOWN) {
fprintSegment(f, (2 + indent) * INDENT, "default", INDENTVALUE);
fprint(f, "%s", getValueString(&smiNode->value, smiType));
fprint(f, ";\n");
}
if (smiNode->format) {
fprintSegment(f, (2 + indent) * INDENT, "format", INDENTVALUE);
fprint(f, "\"%s\";\n",smiNode->format);
}
if (smiNode->units) {
fprintSegment(f, (2 + indent) * INDENT, "units", INDENTVALUE);
fprint(f, "\"%s\";\n", smiNode->units);
}
if ((smiNode->status != SMI_STATUS_CURRENT) &&
(smiNode->status != SMI_STATUS_UNKNOWN) &&
(smiNode->status != SMI_STATUS_MANDATORY) &&
(smiNode->status != SMI_STATUS_OPTIONAL)) {
fprintSegment(f, (2 + indent) * INDENT, "status", INDENTVALUE);
fprint(f, "%s;\n", getStringStatus(smiNode->status));
}
if (smiNode->description) {
fprintSegment(f, (2 + indent) * INDENT, "description",
INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, (2 + indent) * INDENT,
smiNode->description);
fprint(f, ";\n");
}
if (smiNode->reference) {
fprintSegment(f, (2 + indent) * INDENT, "reference",
INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, (2 + indent) * INDENT,
smiNode->reference);
fprint(f, ";\n");
}
i++;
}
if (i) {
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "};\n\n");
}
}
static void
addMetrics(Metrics *metrics, SmiModule *smiModule)
{
SmiNode *smiNode;
SmiType *smiType;
size_t len;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
len = smiNode->description ? strlen(smiNode->description) : 0;
switch (smiNode->nodekind) {
case SMI_NODEKIND_TABLE:
incrStatusCounter(&metrics->statusTables, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrLengthCounter(&metrics->lengthTables,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
break;
case SMI_NODEKIND_ROW:
incrIndexCounter(&metrics->indexTables, smiNode->indexkind);
incrLengthCounter(&metrics->lengthRows,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrRowStatusCounter(smiNode);
{
int cnt = 0;
foreachIndexDo(NULL, smiNode, count, &cnt);
incrIndexLenCounter(&metrics->indexLenTables, cnt);
foreachIndexDo(NULL, smiNode, yadayada, smiModule);
}
{
int cmplx = 0;
foreachIndexDo(NULL, smiNode, complexity, &cmplx);
incrIndexComplexityCounter(smiModule, smiNode, cmplx);
incrIndexComplexityMetric(&metrics->indexComplexity, cmplx);
}
// count the childs ...
{
SmiModule *smiModule = smiGetModule("SNMPv2-TC");
SmiNode *childNode;
SmiType *rowStatus = smiGetType(smiModule, "RowStatus");
SmiType *storageType = smiGetType(smiModule, "StorageType");
// include index elements not in table
int n = 0;
for (childNode = smiGetFirstChildNode(smiNode);
childNode;
childNode = smiGetNextChildNode(childNode)) {
n++;
if (rowStatus == smiGetNodeType(childNode)) {
fprintf(stderr, "**** GEEEEEE - ROWSTATUS\n");
}
if (storageType == smiGetNodeType(childNode)) {
fprintf(stderr, "**** GEEEEEE - STORAGETYPE\n");
}
}
incrTableLenCounter(&metrics->tableLength, n);
}
break;
case SMI_NODEKIND_COLUMN:
incrBasetypeCounter(&metrics->basetypesColumns, smiNode);
incrBasetypeCounter(&metrics->basetypesAll, smiNode);
incrStatusCounter(&metrics->statusColumns, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrAccessCounter(&metrics->accessColumns, smiNode->access);
incrAccessCounter(&metrics->accessAll, smiNode->access);
incrLengthCounter(&metrics->lengthColumns,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrTypeAndNodeUsageCounter(smiModule, smiNode, INCR_TYPE);
break;
case SMI_NODEKIND_SCALAR:
incrBasetypeCounter(&metrics->basetypesScalars, smiNode);
incrBasetypeCounter(&metrics->basetypesAll, smiNode);
incrStatusCounter(&metrics->statusScalars, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrAccessCounter(&metrics->accessScalars, smiNode->access);
incrAccessCounter(&metrics->accessAll, smiNode->access);
incrLengthCounter(&metrics->lengthScalars,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrTypeAndNodeUsageCounter(smiModule, smiNode, INCR_TYPE);
break;
case SMI_NODEKIND_NOTIFICATION:
incrStatusCounter(&metrics->statusNotifications, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrLengthCounter(&metrics->lengthNotifications,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
break;
case SMI_NODEKIND_GROUP:
incrStatusCounter(&metrics->statusGroups, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
break;
case SMI_NODEKIND_COMPLIANCE:
incrStatusCounter(&metrics->statusCompliances, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
break;
}
}
for (smiType = smiGetFirstType(smiModule);
smiType;
smiType = smiGetNextType(smiType)) {
/*
* Ignore all types with empty descriptions coming from the
* "SNMPv2-SMI" module since they are not really defined
* types but part of the language itself.
*/
if (! smiType->description) {
SmiModule *m = smiGetTypeModule(smiType);
if (m && strcmp(m->name, "SNMPv2-SMI") == 0) {
continue;
}
}
incrStatusCounter(&metrics->statusTypes, smiType->status);
incrStatusCounter(&metrics->statusAll, smiType->status);
incrLengthCounter(&metrics->lengthTypes,
smiType->description, smiType->reference,
smiType->units, smiType->format);
incrLengthCounter(&metrics->lengthAll,
smiType->description, smiType->reference,
smiType->units, smiType->format);
}
}
static void fprintNode(FILE *f, int indent, SmiNode *smiNode,
SmiNode *lastSmiNode)
{
SmiModule *smiModule;
SmiType *smiType;
char *tag = NULL;
if (smiNode->nodekind == SMI_NODEKIND_NODE) {
tag = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_CAPABILITIES) {
tag = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_TABLE) {
tag = "table";
} else if (smiNode->nodekind == SMI_NODEKIND_ROW) {
indent += INDENT;
tag = "row";
} else if (smiNode->nodekind == SMI_NODEKIND_COLUMN) {
indent += 2 * INDENT;
tag = "column";
} else if (smiNode->nodekind == SMI_NODEKIND_SCALAR) {
tag = "scalar";
}
if (lastSmiNode
&& lastSmiNode->nodekind == SMI_NODEKIND_COLUMN
&& smiNode->nodekind != SMI_NODEKIND_COLUMN) {
fprintNodeEndTag(f, indent + INDENT, "row");
fprintNodeEndTag(f, indent, "table");
}
smiType = smiGetNodeType(smiNode);
fprintNodeStartTag(f, indent, tag, smiNode);
if (smiType && (smiType->basetype != SMI_BASETYPE_UNKNOWN)) {
fprintSegment(f, indent + INDENT, "<syntax>\n", 0);
smiModule = smiGetTypeModule(smiType);
if (smiType->name && smiModule) {
fprintSegment(f, indent + 2 *INDENT, "", 0);
fprint(f, "<type ");
fprintf(f, "module=\"%s\" name=\"%s\"/>\n",
smiModule->name, smiType->name);
} else {
fprintTypedef(f, indent + 2 * INDENT, smiType);
}
fprintSegment(f, indent + INDENT, "</syntax>\n", 0);
}
if ((smiNode->nodekind != SMI_NODEKIND_TABLE) &&
(smiNode->nodekind != SMI_NODEKIND_ROW) &&
(smiNode->nodekind != SMI_NODEKIND_CAPABILITIES) &&
(smiNode->nodekind != SMI_NODEKIND_NODE)) {
fprintAccess(f, indent + INDENT, smiNode->access);
}
if (smiType) {
fprintValue(f, indent + INDENT, &smiNode->value, smiType);
}
fprintFormat(f, indent + INDENT, smiNode->format);
fprintUnits(f, indent + INDENT, smiNode->units);
if (smiNode->nodekind == SMI_NODEKIND_ROW) {
fprintIndex(f, indent + INDENT, smiNode);
}
fprintDescription(f, indent + INDENT, smiNode->description);
fprintReference(f, indent + INDENT, smiNode->reference);
if (smiNode->nodekind != SMI_NODEKIND_ROW
&& smiNode->nodekind != SMI_NODEKIND_TABLE) {
fprintNodeEndTag(f, indent, tag);
}
}
static void printHeaderTypedef(FILE *f, SmiModule *smiModule,
SmiNode *groupNode)
{
SmiNode *smiNode;
SmiType *smiType;
char *cModuleName, *cGroupName, *cName;
unsigned minSize, maxSize;
cModuleName = translateLower(smiModule->name);
cGroupName = translate(groupNode->name);
fprintf(f,
"/*\n"
" * C type definitions for %s::%s.\n"
" */\n\n",
smiModule->name, groupNode->name);
fprintf(f, "typedef struct %s {\n", cGroupName);
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
#if 0
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)
#endif
) {
smiType = smiGetNodeType(smiNode);
if (!smiType) {
continue;
}
cName = translate(smiNode->name);
switch (smiType->basetype) {
case SMI_BASETYPE_OBJECTIDENTIFIER:
maxSize = smiGetMaxSize(smiType);
minSize = smiGetMinSize(smiType);
fprintf(f,
" uint32_t *%s;\n", cName);
if (maxSize != minSize) {
fprintf(f,
" size_t _%sLength;\n", cName);
}
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_BITS:
maxSize = smiGetMaxSize(smiType);
minSize = smiGetMinSize(smiType);
fprintf(f,
" u_char *%s;\n", cName);
if (maxSize != minSize) {
fprintf(f,
" size_t _%sLength;\n", cName);
}
break;
case SMI_BASETYPE_ENUM:
case SMI_BASETYPE_INTEGER32:
fprintf(f,
" int32_t *%s;\n", cName);
break;
case SMI_BASETYPE_UNSIGNED32:
fprintf(f,
" uint32_t *%s;\n", cName);
break;
case SMI_BASETYPE_INTEGER64:
fprintf(f,
" int64_t *%s; \n", cName);
break;
case SMI_BASETYPE_UNSIGNED64:
fprintf(f,
" uint64_t *%s; \n", cName);
break;
default:
fprintf(f,
" /* ?? */ __%s; \n", cName);
break;
}
xfree(cName);
}
}
fprintf(f,
" void *_clientData;\t\t"
"/* pointer to client data structure */\n");
if (groupNode->nodekind == SMI_NODEKIND_ROW) {
fprintf(f, " struct %s *_nextPtr;\t"
"/* pointer to next table entry */\n", cGroupName);
}
fprintf(f,
"\n /* private space to hold actual values */\n\n");
for (smiNode = smiGetFirstChildNode(groupNode);
smiNode;
smiNode = smiGetNextChildNode(smiNode)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
#if 0
&& (smiNode->access == SMI_ACCESS_READ_ONLY
|| smiNode->access == SMI_ACCESS_READ_WRITE)
#endif
) {
smiType = smiGetNodeType(smiNode);
if (!smiType) {
continue;
}
cName = translate(smiNode->name);
switch (smiType->basetype) {
case SMI_BASETYPE_OBJECTIDENTIFIER:
maxSize = smiGetMaxSize(smiType);
fprintf(f,
" uint32_t __%s[%u];\n", cName, maxSize);
break;
case SMI_BASETYPE_OCTETSTRING:
case SMI_BASETYPE_BITS:
maxSize = smiGetMaxSize(smiType);
fprintf(f,
" u_char __%s[%u];\n", cName, maxSize);
break;
case SMI_BASETYPE_ENUM:
case SMI_BASETYPE_INTEGER32:
fprintf(f,
" int32_t __%s;\n", cName);
break;
case SMI_BASETYPE_UNSIGNED32:
fprintf(f,
" uint32_t __%s;\n", cName);
break;
case SMI_BASETYPE_INTEGER64:
fprintf(f,
" int64_t __%s; \n", cName);
break;
case SMI_BASETYPE_UNSIGNED64:
fprintf(f,
" uint64_t __%s; \n", cName);
break;
default:
fprintf(f,
" /* ?? */ __%s; \n", cName);
break;
}
xfree(cName);
}
}
fprintf(f, "} %s_t;\n\n", cGroupName);
fprintf(f,
"/*\n"
" * C manager interface stubs for %s::%s.\n"
" */\n\n",
smiModule->name, groupNode->name);
fprintf(f, "extern int\n"
"%s_mgr_get_%s(struct snmp_session *s, %s_t **%s);\n",
cModuleName, cGroupName, cGroupName, cGroupName);
fprintf(f, "\n");
fprintf(f,
"/*\n"
" * C agent interface stubs for %s::%s.\n"
" */\n\n",
smiModule->name, groupNode->name);
fprintf(f, "extern int\n"
"%s_agt_read_%s(%s_t *%s);\n",
cModuleName, cGroupName, cGroupName, cGroupName);
fprintf(f, "extern int\n"
"%s_agt_register_%s();\n\n",
cModuleName, cGroupName);
xfree(cGroupName);
xfree(cModuleName);
}