static int fprintImports(FILE *f, SmiModule *smiModule, char *prefix,
Imports *backtrace)
{
SmiModule *smiModule2;
Imports *imports, *imp;
int i, n, recurse = 0, done = 0;
for (imp = backtrace; imp; imp = imp->nextPtr) {
if (strcmp(imp->module, smiModule->name) == 0) {
fprintf(stderr, "%s (recursion - aborted)\n", prefix);
return 0;
}
}
imp = (Imports *) xmalloc(sizeof(Imports));
imp->module = smiModule->name;
imp->nextPtr = backtrace;
backtrace = imp;
imports = getImports(smiModule, &n);
for (i = 0; i < n; i++) {
char *newprefix;
smiModule2 = smiGetModule(imports[i].module);
recurse = (NULL == smiGetFirstImport(smiModule2));
if (recurse) {
fprintf(f, "%s |\n", prefix);
}
fprintf(f, "%s +--%s [%d identifier%s]\n", prefix, imports[i].module,
imports[i].count, imports[i].count > 1 ? "s" : "");
newprefix = xmalloc(strlen(prefix)+10);
strcpy(newprefix, prefix);
if (i == n-1) {
strcat(newprefix, " ");
} else {
strcat(newprefix, " |");
}
done = fprintImports(f, smiModule2, newprefix, backtrace);
if (! recurse && done) {
if (i == n-1) {
fprintf(f, "%s \n", prefix);
} else {
fprintf(f, "%s |\n", prefix);
}
}
xfree(newprefix);
}
freeImports(imports, n);
xfree(backtrace);
return recurse;
}
void MibViewLoader::Load(QStringList &modules)
{
char *modulename;
SmiModule *smiModule;
SmiModule **modv = NULL;
int modc = 0;
modv = (SmiModule **)malloc(modules.count() * sizeof(SmiModule *));
modc = 0;
QString module;
for (int j=0; j < views.count(); j++)
{
views[j]->SetDirty();
views[j]->clear();
}
for (int i=0; i < modules.count(); i++)
{
module = modules[i];
modulename = smiLoadModule(module.toLatin1().data());
smiModule = modulename ? smiGetModule(modulename) : NULL;
if (smiModule)
modv[modc++] = smiModule;
else
{
emit LogError(QString("Error: `%1` module cannot be loaded (not in PATHS)")
.arg(module.toLatin1().data()));
}
}
pmodc = modc;
if (pmodv)
free(pmodv);
pmodv = modv;
}
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);
}
}
