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 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) && childNode->status == SMI_STATUS_CURRENT) { 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 isGroup(SmiNode *smiNode) { SmiNode *childNode; if (smiNode->nodekind == SMI_NODEKIND_ROW) { return 1; } for(childNode = smiGetFirstChildNode(smiNode); childNode; childNode = smiGetNextChildNode(childNode)) { if (childNode->nodekind == SMI_NODEKIND_SCALAR) { return 1; } } return 0; }
/* * adds the index to an augmenting table (row-element) */ static void diaPrintAugmentIndex(GraphNode *tNode) { GraphEdge *tEdge; SmiElement *smiElement; for (tEdge = graphGetFirstEdgeByNode(graph, tNode); tEdge; tEdge = graphGetNextEdgeByNode(graph, tEdge, tNode)) { if (tEdge->indexkind == SMI_INDEX_AUGMENT) { for (smiElement = smiGetFirstElement( smiGetFirstChildNode(tEdge->startNode->smiNode)); smiElement; smiElement = smiGetNextElement(smiElement)) { if (!cmpSmiNodes(tNode->smiNode, tEdge->startNode->smiNode)) { diaPrintXMLAttribute(smiGetElementNode(smiElement),1); } } } } }
MibNode * MibViewLoader::PopulateSubTree (SmiNode *smiNode, MibNode *parent, MibNode *sibling) { SmiNode *childNode; MibNode *current = NULL, *prev = NULL; if (smiNode) { current = new MibNode(SmiKindToMibNodeType(smiNode->nodekind), smiNode, parent, sibling); for (childNode = smiGetFirstChildNode(smiNode); childNode; childNode = smiGetNextChildNode(childNode)) { if (PruneSubTree(childNode)) continue; prev = PopulateSubTree(childNode, current, prev); } } return current; }
static void printAgtRegister(FILE *f, SmiNode *groupNode, int cnt) { SmiNode *smiNode; char *cGroupName; int num = 0; 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++; } } fprintf(f, "\n"); if (cnt == 1) { fprintf(f, "/*\n" " * Registration functions for the various MIB groups.\n" " */\n\n"); } cGroupName = translate(groupNode->name); fprintf(f, "int register_%s()\n{\n", cGroupName); fprintf(f, " return register_mib(\"%s\",\n" " %s_variables,\n" " sizeof(struct variable),\n" " sizeof(%s_variables)/sizeof(struct variable),\n" " %s_base,\n" " sizeof(%s_base)/sizeof(oid));\n", cGroupName, cGroupName, cGroupName, cGroupName, cGroupName); fprintf(f, "};\n\n"); xfree(cGroupName); }
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 printGroup(int *x, int *y, SmiNode *smiNode) { SmiNode *childNode; 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) { *y += Y_OFFSET; sprintf(string, "%s(%d)", childNode->name, childNode->oid[childNode->oidlen-1]); printString(*x + X_INDENT, *y, 0, string); } } } *y += Y_OFFSET; }
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 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 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); }
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 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 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 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 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); }
static void diaPrintXMLObject(GraphNode *node, float x, float y) { SmiElement *smiElement; if (!node) return; if (node->dia.flags & DIA_PRINT_FLAG) return; node->dia.x = x; node->dia.y = y; node->dia.flags |= DIA_PRINT_FLAG; /* object is now printed */ printf(" <object type=\"UML - Class\" version=\"0\" id=\"%s\">\n", node->smiNode->name); printf(" <attribute name=\"obj_pos\">\n"); printf(" <point val=\"%.2f,%.2f\"/>\n",x,y); printf(" </attribute>\n"); printf(" <attribute name=\"obj_bb\">\n"); printf(" <rectangle val=\"0.0,0.0;0.0,0.0\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"elem_corner\">\n"); printf(" <point val=\"%.2f,%.2f\"/>\n",x,y); printf(" </attribute>\n"); printf(" <attribute name=\"elem_width\">\n"); printf(" <real val=\"%.2f\"/>\n",node->dia.w); printf(" </attribute>\n"); printf(" <attribute name=\"elem_height\">\n"); printf(" <real val=\"%.2f\"/>\n",node->dia.h); printf(" </attribute>\n"); printf(" <attribute name=\"name\">\n"); printf(" <string>#%s#</string>\n", smiGetFirstChildNode(node->smiNode)->name); printf(" </attribute>\n"); printf(" <attribute name=\"stereotype\">\n"); printf(" <string>#%s#</string>\n", STEREOTYPE); printf(" </attribute>\n"); printf(" <attribute name=\"abstract\">\n"); printf(" <boolean val=\"false\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"suppress_attributes\">\n"); printf(" <boolean val=\"false\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"suppress_operations\">\n"); printf(" <boolean val=\"true\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"visible_attributes\">\n"); printf(" <boolean val=\"true\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"visible_operations\">\n"); printf(" <boolean val=\"false\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"attributes\">\n"); if (node->smiNode->nodekind == SMI_NODEKIND_TABLE) { diaPrintXMLRelatedScalars(node); diaPrintAugmentIndex(node); for (smiElement = smiGetFirstElement( smiGetFirstChildNode(node->smiNode)); smiElement; smiElement = smiGetNextElement(smiElement)) { diaPrintXMLAttribute(smiGetElementNode(smiElement),1); } if (PRINT_DETAILED_ATTR) { diaPrintXMLAllColumns(node); } } printf(" </attribute>\n"); printf(" <attribute name=\"operations\"/>\n"); printf(" <attribute name=\"template\">\n"); printf(" <boolean val=\"false\"/>\n"); printf(" </attribute>\n"); printf(" <attribute name=\"templates\"/>\n"); printf(" </object>\n"); }
/* * 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; }
static void dumpSizeOfPDU(FILE *f, SmiModule *smiModule, SmiNode *smiNode) { SmiNode *child; int worst = 0; int best = 0; int avg = 0; int b, w, a, n = 0; for (child = smiGetFirstChildNode(smiNode); child; child = smiGetNextChildNode(child)) { if (child->access == SMI_ACCESS_READ_WRITE || child->access == SMI_ACCESS_READ_ONLY) { b = ber_len_varbind(child, len_min); a = ber_len_varbind(child, len_mean); w = ber_len_varbind(child, len_max); 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); if (detail) { for (child = smiGetFirstChildNode(smiNode); child; child = smiGetNextChildNode(child)) { if (child->access == SMI_ACCESS_READ_WRITE || child->access == SMI_ACCESS_READ_ONLY) { b = ber_len_varbind(child, len_min); a = ber_len_varbind(child, len_mean); w = ber_len_varbind(child, len_max); fprintf(f, "%-23s %-23s \t%d\t[%d..%d]\n", "", child->name, a, b, w); } } } }
static void printMgrGetMethod(FILE *f, SmiModule *smiModule, SmiNode *groupNode) { SmiNode *smiNode; char *cModuleName, *cGroupName; cModuleName = translateLower(smiModule->name); cGroupName = translate(groupNode->name); fprintf(f, "int %s_mgr_get_%s(struct snmp_session *s, %s_t **%s)\n" "{\n" " struct snmp_session *peer;\n" " struct snmp_pdu *request, *response;\n" " struct variable_list *vars;\n" " int status;\n" "\n", cModuleName, cGroupName, cGroupName, cGroupName); fprintf(f, " request = snmp_pdu_create(SNMP_MSG_GETNEXT);\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)) { fprintf(f, " snmp_add_null_var(request, %s, sizeof(%s)/sizeof(oid));\n", smiNode->name, smiNode->name); } } fprintf(f, "\n" " peer = snmp_open(s);\n" " if (!peer) {\n" " snmp_free_pdu(request);\n" " return -1;\n" " }\n" "\n" " status = snmp_synch_response(peer, request, &response);\n" " if (status != STAT_SUCCESS) {\n" " if (response) snmp_free_pdu(response);\n" " snmp_close(peer);\n" " return -2;\n" " }\n" "\n"); /* generate code for error checking and handling */ fprintf(f, " *%s = (%s_t *) malloc(sizeof(%s_t));\n" " if (! *%s) {\n" " if (response) snmp_free_pdu(response);\n" " snmp_close(peer);\n" " return -4;\n" " }\n" "\n", cGroupName, cGroupName, cGroupName, cGroupName); fprintf(f, " for (vars = response->variables; vars; vars = vars->next_variable) {\n"); printMgrGetScalarAssignement(f, groupNode); fprintf(f, " }\n" "\n"); #if 0 if (response->errstat != SNMP_ERR_NOERROR) { return -3; } /* copy to data structures */ /* cleanup */ #endif fprintf(f, " if (response) snmp_free_pdu(response);\n" "\n" " if (snmp_close(peer) == 0) {\n" " return -5;\n" " }\n" "\n" " return 0;\n" "}\n\n"); xfree(cGroupName); xfree(cModuleName); }