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); sprintf(append, ".%u%s", 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->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 void fprintRefinement(FILE *f, int indent, SmiRefinement *smiRefinement) { SmiModule *smiModule; SmiNode *smiNode; SmiType *smiType; smiNode = smiGetRefinementNode(smiRefinement); smiModule = smiGetNodeModule(smiNode); fprintSegment(f, indent, "<refinement ", 0); fprintf(f, "module=\"%s\" name=\"%s\">\n", smiModule->name, smiNode->name); smiType = smiGetRefinementType(smiRefinement); if (smiType) { fprintSegment(f, indent + INDENT, "<syntax>\n", 0); fprintTypedef(f, indent + 2 * INDENT, smiType); fprintSegment(f, indent + INDENT, "</syntax>\n", 0); } smiType = smiGetRefinementWriteType(smiRefinement); if (smiType) { fprintSegment(f, indent + INDENT, "<writesyntax>\n", 0); fprintTypedef(f, indent + 2 * INDENT, smiType); fprintSegment(f, indent + INDENT, "</writesyntax>\n", 0); } if (smiRefinement->access != SMI_ACCESS_UNKNOWN) { fprintAccess(f, indent + INDENT, smiRefinement->access); } fprintDescription(f, indent + INDENT, smiRefinement->description); fprintSegment(f, indent, "</refinement>\n", 0); }
static void fprintComplGroups(FILE *f, int indent, SmiNode *smiNode) { SmiNode *optSmiNode; SmiModule *optSmiModule; SmiOption *smiOption; if (! smiGetFirstElement(smiNode) && !smiGetFirstOption(smiNode)) { return; } fprintSegment(f, indent, "<requires>\n", 0); fprintElementList(f, indent + INDENT, "mandatory", smiGetFirstElement(smiNode)); for(smiOption = smiGetFirstOption(smiNode); smiOption; smiOption = smiGetNextOption(smiOption)) { optSmiNode = smiGetOptionNode(smiOption); optSmiModule = smiGetNodeModule(optSmiNode); fprintSegment(f, indent + INDENT, "", 0); fprint(f, "<option module=\"%s\" name=\"%s\">\n", optSmiModule->name, optSmiNode->name); fprintDescription(f, indent + 2 * INDENT, smiOption->description); fprintSegment(f, indent + INDENT, "</option>\n", 0); } fprintSegment(f, indent, "</requires>\n", 0); }
static void fprintIndex(FILE *f, int indent, SmiNode *smiNode) { SmiNode *relatedNode; SmiModule *relatedModule = NULL; fprintSegment(f, indent, "<linkage", 0); if (smiNode->implied) { fprint(f, " implied=\"true\""); } fprint(f, ">\n"); relatedNode = smiGetRelatedNode(smiNode); if (relatedNode) { relatedModule = smiGetNodeModule(relatedNode); } switch (smiNode->indexkind) { case SMI_INDEX_INDEX: fprintElementList(f, indent + INDENT, "index", smiGetFirstElement(smiNode)); break; case SMI_INDEX_AUGMENT: if (relatedNode && relatedModule) { fprintSegment(f, indent + INDENT, "", 0); fprint(f, "<augments module=\"%s\" name=\"%s\"/>\n", relatedModule->name, relatedNode->name); } /* TODO: else print error */ break; case SMI_INDEX_REORDER: if (relatedNode && relatedModule) { fprintSegment(f, indent + INDENT, "", 0); fprint(f, "<reorders module=\"%s\" name=\"%s\"/>\n", relatedModule->name, relatedNode->name); fprintElementList(f, indent + INDENT, "index", smiGetFirstElement(smiNode)); } /* TODO: else print error */ break; case SMI_INDEX_SPARSE: if (relatedNode && relatedModule) { fprintSegment(f, indent + INDENT, "", 0); fprint(f, "<sparse module=\"%s\" name=\"%s\"/>\n", relatedModule->name, relatedNode->name); } /* TODO: else print error */ break; case SMI_INDEX_EXPAND: if (relatedNode && relatedModule) { fprintSegment(f, indent + INDENT, "", 0); fprint(f, "<expands module=\"%s\" name=\"%s\"/>\n", relatedModule->name, relatedNode->name); fprintElementList(f, indent + INDENT, "index", smiGetFirstElement(smiNode)); } /* TODO: else print error */ break; case SMI_INDEX_UNKNOWN: break; } fprintSegment(f, indent, "</linkage>\n", 0); }
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 fprintElementList(FILE *f, int indent, const char *tag, SmiElement *smiElement) { SmiModule *smiModule; SmiNode *smiNode; for (; smiElement; smiElement = smiGetNextElement(smiElement)) { smiNode = smiGetElementNode(smiElement); smiModule = smiGetNodeModule(smiNode); fprintSegment(f, indent, "", 0); fprint(f, "<%s module=\"%s\" name=\"%s\"/>\n", tag, smiModule->name, smiNode->name); } }
int MibViewLoader::IsPartOfLoadedModules(SmiNode *smiNode) { SmiModule *smiModule; int i; smiModule = smiGetNodeModule(smiNode); for (i = 0; i < pmodc; i++) { if (strcmp(pmodv[i]->name, smiModule->name) == 0) { return 1; } } return 0; }
/* * prints all columns objects of the given node */ static void diaPrintXMLAllColumns(GraphNode *node) { SmiModule *module = NULL; SmiNode *smiNode = NULL; SmiNode *ppNode; module = smiGetNodeModule(node->smiNode); for (smiNode = smiGetFirstNode(module, SMI_NODEKIND_COLUMN); smiNode; smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COLUMN)) { ppNode = smiGetParentNode(smiNode); ppNode = smiGetParentNode(ppNode); if (!algIsIndexElement(node->smiNode, smiNode) && cmpSmiNodes(node->smiNode, ppNode)) diaPrintXMLAttribute(smiNode, 0); } }
int MibViewLoader::PruneSubTree(SmiNode *smiNode) { SmiNode *childNode; const int confmask = (SMI_NODEKIND_GROUP | SMI_NODEKIND_COMPLIANCE); const int leafmask = (SMI_NODEKIND_GROUP | SMI_NODEKIND_COMPLIANCE | SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR | SMI_NODEKIND_ROW | SMI_NODEKIND_NOTIFICATION); if (! smiNode) { return 1; } /* * First, prune all nodes which the user has told us to ignore. * In the case of ignoreleafs, we have to special case nodes with * an unknown status (which actually represent OBJECT-IDENTITY * definitions). More special case code is needed to exclude * module identity nodes. */ if (ignoreconformance && (smiNode->nodekind & confmask)) { return 1; } if (ignoreleafs) { if (smiNode->nodekind & leafmask) { return 1; } if (smiNode->nodekind == SMI_NODEKIND_NODE && smiNode->status != SMI_STATUS_UNKNOWN) { SmiModule *smiModule = smiGetNodeModule(smiNode); if (smiModule && smiNode != smiGetModuleIdentityNode(smiModule)) { return 1; } } } /* * Next, generally do not prune nodes that belong to the set of * modules we are looking at. */ if (IsPartOfLoadedModules(smiNode)) { if (!ignoreconformance || !smiGetFirstChildNode(smiNode)) { return 0; } } /* * Finally, prune all nodes where all child nodes are pruned. */ for (childNode = smiGetFirstChildNode(smiNode); childNode; childNode = smiGetNextChildNode(childNode)) { /* * In the case of ignoreleafs, we have to peek at the child * nodes. Otherwise, we would prune too much. we still want to * see the path to the leafs we have pruned away. This also * interact with the semantics of ignoreconformance since we * still want in combination with ignoreleafs to see the path * to the pruned conformance leafs. */ if (ignoreleafs && (childNode->nodekind & leafmask)) { if (IsPartOfLoadedModules(childNode)) { if (ignoreconformance && (childNode->nodekind & confmask)) { return 1; } return 0; } } if (! PruneSubTree(childNode)) { return 0; } } return 1; }
static void fprintGroup(FILE *f, SmiNode *smiNode, char c, int *typelen, int *namelen, int pass) { SmiElement *smiElement; SmiNode *smiObject; SmiModule *smiModule; char *type_name; int tlen = 9, nlen = 9; switch (smiNode->nodekind) { case SMI_NODEKIND_GROUP: for (smiElement = smiGetFirstElement(smiNode); smiElement; smiElement = smiGetNextElement(smiElement)) { smiObject = smiGetElementNode(smiElement); smiModule = smiGetNodeModule(smiNode); type_name = getTypeName(smiObject); if (pass == 1) { if (type_name) { int newlen = strlen(type_name); tlen = (tlen < newlen) ? newlen : tlen; } if (smiObject->name) { int newlen = strlen(smiObject->name); nlen = (nlen < newlen) ? newlen : nlen; } } else if (pass == 2) { fprintf(f, " %c%c%s %-*s %-*s (%s)\n", getStatusChar(smiObject->status), c, getFlags(smiObject), *typelen, type_name ? type_name : "-", *namelen, smiObject->name, smiNode->name); } xfree(type_name); } break; case SMI_NODEKIND_SCALAR: case SMI_NODEKIND_COLUMN: smiObject = smiNode; type_name = getTypeName(smiObject); if (pass == 1) { if (type_name) { int newlen = strlen(type_name); tlen = tlen < newlen ? newlen : tlen; } if (smiObject->name) { int newlen = strlen(smiObject->name); nlen = (nlen < newlen) ? newlen : nlen; } } else if (pass == 2) { fprintf(f, " %c%c%s %-*s %s\n", getStatusChar(smiObject->status), 'r', getFlags(smiObject), *typelen, type_name ? type_name : "-", smiObject->name); } xfree(type_name); break; default: break; } if (pass == 1) { if (typelen) *typelen = tlen; if (namelen) *namelen = nlen; } }
/* * diaCalcSize * * Calculates the size of a given node for the UML representation. */ static GraphNode *diaCalcSize(GraphNode *node) { GraphEdge *tEdge; SmiNode *tNode,*ppNode; SmiElement *smiElement; SmiModule *module; if (node->smiNode->nodekind == SMI_NODEKIND_SCALAR) return node; node->dia.w = (strlen(node->smiNode->name)+4) * HEADFONTSIZETABLE + HEADSPACESIZETABLE; node->dia.h = TABLEHEIGHT; for (smiElement = smiGetFirstElement( smiGetFirstChildNode(node->smiNode)); smiElement; smiElement = smiGetNextElement(smiElement)) { tNode = smiGetElementNode(smiElement); node->dia.w = max(node->dia.w, (strlen(tNode->name) + strlen(algGetTypeName(tNode)) + strlen(INDEXPROPERTY)) * ATTRFONTSIZE + ATTRSPACESIZE); node->dia.h += TABLEELEMHEIGHT; } for (tEdge = graphGetFirstEdgeByNode(graph,node); tEdge; tEdge = graphGetNextEdgeByNode(graph, tEdge, node)) { if (tEdge->startNode == node && tEdge->endNode->smiNode->nodekind == SMI_NODEKIND_SCALAR) { node->dia.h += TABLEELEMHEIGHT; tNode = tEdge->endNode->smiNode; node->dia.w = max(node->dia.w, (strlen(tNode->name) + strlen(algGetTypeName(tNode))) * ATTRFONTSIZE + ATTRSPACESIZE); } } if (PRINT_DETAILED_ATTR && node->smiNode->nodekind == SMI_NODEKIND_TABLE) { module = smiGetNodeModule(node->smiNode); for (tNode = smiGetFirstNode(module, SMI_NODEKIND_COLUMN); tNode; tNode = smiGetNextNode(tNode, SMI_NODEKIND_COLUMN)) { ppNode = smiGetParentNode(tNode); ppNode = smiGetParentNode(ppNode); if (cmpSmiNodes(node->smiNode, ppNode)) { int len; char *typeName; typeName = algGetTypeName(tNode); len = strlen(tNode->name) + (typeName ? strlen(typeName) : 0); node->dia.h += TABLEELEMHEIGHT; node->dia.w = max(node->dia.w, len) * ATTRFONTSIZE + ATTRSPACESIZE; } } } return node; }