{"id":48467725,"url":"https://github.com/golangsnmp/gomib","last_synced_at":"2026-04-07T05:03:46.796Z","repository":{"id":337997589,"uuid":"1141559226","full_name":"golangsnmp/gomib","owner":"golangsnmp","description":"Pure go permissive MIB Parser","archived":false,"fork":false,"pushed_at":"2026-04-03T15:11:10.000Z","size":7016,"stargazers_count":6,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-04-03T18:36:00.752Z","etag":null,"topics":["asn1","mibs","parser","snmp"],"latest_commit_sha":null,"homepage":"","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/golangsnmp.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-01-25T02:26:20.000Z","updated_at":"2026-04-03T15:11:18.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/golangsnmp/gomib","commit_stats":null,"previous_names":["golangsnmp/gomib"],"tags_count":16,"template":false,"template_full_name":null,"purl":"pkg:github/golangsnmp/gomib","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/golangsnmp%2Fgomib","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/golangsnmp%2Fgomib/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/golangsnmp%2Fgomib/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/golangsnmp%2Fgomib/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/golangsnmp","download_url":"https://codeload.github.com/golangsnmp/gomib/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/golangsnmp%2Fgomib/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31500407,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-07T03:10:19.677Z","status":"ssl_error","status_checked_at":"2026-04-07T03:10:13.982Z","response_time":105,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["asn1","mibs","parser","snmp"],"created_at":"2026-04-07T05:03:46.693Z","updated_at":"2026-04-07T05:03:46.781Z","avatar_url":"https://github.com/golangsnmp.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# gomib\n\n[![CI](https://github.com/golangsnmp/gomib/actions/workflows/ci.yml/badge.svg)](https://github.com/golangsnmp/gomib/actions/workflows/ci.yml)\n[![PkgGoDev](https://pkg.go.dev/badge/github.com/golangsnmp/gomib)](https://pkg.go.dev/github.com/golangsnmp/gomib)\n[![Go Report Card](https://goreportcard.com/badge/github.com/golangsnmp/gomib)](https://goreportcard.com/report/github.com/golangsnmp/gomib)\n\nGo library for parsing and querying SNMP MIB files.\n\nSupports SMIv1 and SMIv2 modules. Loads MIBs from directories, directory trees, or embedded filesystems. Resolves imports, builds the OID tree, and provides typed access to objects, types, notifications, and conformance definitions.\n\n## Install\n\n```\ngo get github.com/golangsnmp/gomib\n```\n\nRequires Go 1.24+.\n\n## Quick start\n\n```go\npackage main\n\nimport (\n    \"context\"\n    \"fmt\"\n    \"log\"\n\n    \"github.com/golangsnmp/gomib\"\n)\n\nfunc main() {\n    m, err := gomib.Load(context.Background(),\n        gomib.WithSystemPaths(),\n        gomib.WithModules(\"IF-MIB\"),\n    )\n    if err != nil {\n        log.Fatal(err)\n    }\n\n    obj := m.Object(\"ifIndex\")\n    if obj != nil {\n        fmt.Printf(\"%s  %s  %s  %s\\n\", obj.Name(), obj.OID(), obj.Type().Name(), obj.Access())\n        // ifIndex  1.3.6.1.2.1.2.2.1.1  InterfaceIndex  read-only\n    }\n}\n```\n\n## Loading MIBs\n\n```go\n// Load everything from a source (parses all files)\nm, err := gomib.Load(ctx, gomib.WithSource(src))\n\n// Load only specific modules and their transitive dependencies.\n// Faster when the source contains hundreds of MIBs but you only need a few.\nm, err := gomib.Load(ctx, gomib.WithSource(src), gomib.WithModules(\"IF-MIB\", \"IP-MIB\"))\n```\n\n### Sources\n\n`Dir` recursively indexes a directory tree using content-derived module names. `File`/`Files` load individual files by path. `FS` wraps an `fs.FS` (useful with `embed.FS`). `Multi` tries multiple sources in order.\n\n```go\n// Directory tree (indexed once at construction)\nsrc, err := gomib.Dir(\"/usr/share/snmp/mibs\")\n\n// Individual files (module names auto-detected from content)\nsrc, err := gomib.File(\"/path/to/IF-MIB.mib\")\nsrc, err  = gomib.Files(\"/path/to/IF-MIB.mib\", \"/path/to/IP-MIB.mib\")\n\n// Embedded filesystem\n//go:embed mibs\nvar mibFS embed.FS\nsrc := gomib.FS(\"embedded\", mibFS)\n\n// Combine sources (first match wins)\nsrc := gomib.Multi(systemSrc, vendorSrc)\n```\n\n`MustDir` panics on error for use in `var` blocks.\n\nFiles are matched by extension: no extension, `.mib`, `.smi`, `.txt`, `.my`. Override with `WithExtensions`. Non-MIB files are filtered during loading by checking for `DEFINITIONS` and `::=` in the content.\n\n`ScanModuleNames` extracts module names from raw bytes without a full parse, useful for indexing:\n\n```go\nnames := gomib.ScanModuleNames(content) // e.g. [\"IF-MIB\"]\n```\n\nSources can also list the modules they know about without parsing them:\n\n```go\nsrc, _ := gomib.Dir(\"/usr/share/snmp/mibs\")\nnames, _ := src.ListModules() // e.g. [\"IF-MIB\", \"IP-MIB\", ...]\n```\n\n### Options\n\n```go\ngomib.Load(ctx,\n    gomib.WithSource(src),\n    gomib.WithSystemPaths(),                             // discover net-snmp/libsmi paths\n    gomib.WithLogger(slog.Default()),                    // enable debug/trace logging\n    gomib.WithResolverStrictness(mib.ResolverPermissive),    // strictness preset\n    gomib.WithDiagnosticConfig(mib.DiagnosticConfig{   // fine-grained control\n        Reporting: mib.ReportingDefault,\n        FailAt: mib.SeverityError,\n        Ignore: []string{\"identifier-underscore\"},\n    }),\n)\n```\n\n## Querying\n\nLookup methods take a plain name and return nil if not found:\n\n```go\nobj := m.Object(\"ifIndex\")\nnode := m.Node(\"ifEntry\")\ntyp := m.Type(\"DisplayString\")\n```\n\nFor qualified lookup, scope through the module (see [Module-scoped queries](#module-scoped-queries) below).\n\nOther lookup methods: `Node`, `Type`, `Notification`, `Group`, `Compliance`, `Capability`.\n\n`Symbol` provides a unified lookup across all definition types:\n\n```go\nsym := m.Symbol(\"ifIndex\")       // returns a Symbol wrapping any definition kind\nsym.Name()                       // \"ifIndex\"\nsym.Object()                     // *Object (or nil if not an OBJECT-TYPE)\nsym.Node()                       // *Node\nsym.IsZero()                     // true if nothing was found\n```\n\n### Resolve\n\n`Resolve` accepts any common format - plain name, qualified name, or numeric OID - and returns the matching node:\n\n```go\nnode := m.Resolve(\"ifDescr\")                     // plain name\nnode  = m.Resolve(\"IF-MIB::ifDescr\")             // qualified\nnode  = m.Resolve(\"1.3.6.1.2.1.2.2.1.2\")        // numeric OID\nnode  = m.Resolve(\".1.3.6.1.2.1.2.2.1.2\")       // leading dot\n```\n\n`ResolveOID` converts any of those formats to a numeric OID, and also handles instance-suffixed forms:\n\n```go\noid, err := m.ResolveOID(\"IF-MIB::ifDescr.5\")    // OID{1,3,6,1,2,1,2,2,1,2,5}\noid, err  = m.ResolveOID(\"ifDescr.5\")             // same result\noid, err  = m.ResolveOID(\"1.3.6.1.2.1.2.2.1.2\")  // numeric pass-through\n```\n\n`ResolveOID` is the inverse of `FormatOID`:\n\n```go\nformatted := m.FormatOID(oid)       // \"IF-MIB::ifDescr.5\"\nback, _   := m.ResolveOID(formatted) // round-trips to the same OID\n```\n\n### OID lookups\n\nFor cases where you already know the format, lower-level methods avoid parsing:\n\n```go\noid, _ := mib.ParseOID(\"1.3.6.1.2.1.2.2.1.1\")\nnode := m.NodeByOID(oid)            // exact match\nnode  = m.LongestPrefixByOID(oid)   // longest matching prefix\n```\n\n`LookupInstance` returns both the matched node and the instance suffix, which is the standard pattern for processing SNMP varbinds:\n\n```go\nlookup := m.LookupInstance(oid)\nlookup.Node().Name()   // \"ifIndex\"\nlookup.Suffix()        // OID{5} (trailing arcs after the matched node)\n```\n\n### Module-scoped queries\n\n```go\nmod := m.Module(\"IF-MIB\")\nobj := mod.Object(\"ifIndex\")\ntyp := mod.Type(\"InterfaceIndex\")\n```\n\n### Module metadata and imports\n\n`Module` exposes both MODULE-IDENTITY metadata and import-resolution details:\n\n```go\nmod := m.Module(\"IF-MIB\")\n\nmod.Name()         // \"IF-MIB\"\nmod.Language()     // SMIv2\nmod.SourcePath()   // file path, or \"\" for embedded base modules\nmod.IsBase()       // false for user/system modules, true for built-ins\nmod.OID()          // module identity OID\nmod.Organization() // ORGANIZATION clause\nmod.ContactInfo()  // CONTACT-INFO clause\nmod.Description()  // DESCRIPTION clause\nmod.LastUpdated()  // LAST-UPDATED value\nmod.Revisions()    // []Revision\nmod.Imports()      // []Import from the IMPORTS clause\n\nmod.ImportsSymbol(\"DisplayString\") // true if listed in IMPORTS\nmod.IsImportUsed(\"DisplayString\")  // true if referenced during resolution\nmod.ImportSource(\"DisplayString\")  // resolved source module\n```\n\nBase modules are always present and define the SMI language itself:\n\n```go\nbase := m.Module(\"SNMPv2-SMI\")\nbase.IsBase()      // true\nbase.SourcePath()  // \"\"\nbase.Node(\"enterprises\").OID() // 1.3.6.1.4.1\n```\n\nModule introspection methods:\n\n```go\nmod.DefinesSymbol(\"ifIndex\")        // true if module defines this name\nmod.ImportsSymbol(\"DisplayString\")  // true if module imports this name\nmod.IsImportUsed(\"DisplayString\")   // true if import was referenced during resolution\nmod.ImportSource(\"DisplayString\")   // *Module for the source of the import\n\nfor sym := range mod.Definitions() {  // iterate all definitions as Symbol values\n    fmt.Println(sym.Name())\n}\n```\n\n### Collections\n\n```go\nm.Objects()        // all OBJECT-TYPE definitions\nm.Tables()         // tables only\nm.Scalars()        // scalars only\nm.Columns()        // columns only\nm.Rows()           // rows only\nm.Types()          // all type definitions\nm.Notifications()  // all notifications\nm.Groups()         // all groups\nm.Compliances()    // all compliances\nm.Capabilities()   // all capabilities\nm.Modules()        // all loaded modules\nm.AllSymbols()     // all definitions across all modules (iter.Seq[Symbol])\n```\n\n### OID tree iteration\n\n```go\nfor node := range m.Nodes() {\n    fmt.Println(node.OID(), node.Name(), node.Kind())\n}\n\n// Subtree iteration\nnode := m.Node(\"ifEntry\")\nfor child := range node.Subtree() {\n    fmt.Println(child.Name())\n}\n\n// Node metadata (populated for base module OIDs and OBJECT-IDENTITY definitions)\nnode.Description() // OID assignment description text\nnode.Reference()   // reference string\n```\n\n## Objects\n\nEach `Object` carries its type, access level, status, and position in the OID tree:\n\n```go\nobj := m.Object(\"ifType\")\n\nobj.Name()        // \"ifType\"\nobj.OID()         // 1.3.6.1.2.1.2.2.1.3\nobj.Kind()        // column\nobj.Access()      // read-only\nobj.Status()      // current\nobj.Type().Name() // \"IANAifType\"\nobj.Units()       // \"\" (empty if not set)\nobj.Description() // \"The type of interface...\"\n```\n\n### Tables\n\n```go\ntable := m.Object(\"ifTable\")\ntable.IsTable()  // true\n\nrow := table.Entry()           // ifEntry\ncols := row.Columns()          // [ifIndex, ifDescr, ifType, ...]\nidxs := row.EffectiveIndexes() // handles AUGMENTS\n\nfor _, idx := range idxs {\n    fmt.Printf(\"INDEX %s (implied=%v)\\n\", idx.Object.Name(), idx.Implied)\n}\n```\n\nNavigate from any level: `obj.Table()` returns the containing table, `obj.Row()` returns the containing row.\n\n### Effective constraints\n\nConstraints can be defined inline on the object or inherited through the type chain. The `Effective*` methods walk both:\n\n```go\nobj.EffectiveEnums()       // enum values\nobj.EffectiveBits()        // BITS values\nobj.EffectiveRanges()      // value ranges\nobj.EffectiveSizes()       // size constraints\nobj.EffectiveDisplayHint() // display hint string\n```\n\n## Types\n\nTypes form chains: a textual convention references a parent type, which may reference another, down to a base SMI type.\n\n```go\ntyp := m.Type(\"DisplayString\")\n\ntyp.Name()                // \"DisplayString\"\ntyp.IsTextualConvention() // true\ntyp.Base()                // OCTET STRING\ntyp.DisplayHint()         // \"255a\"\ntyp.Sizes()               // [{0 255}]\ntyp.Parent().Name()       // base type reference\n\n// Walk the chain\nfor t := typ; t != nil; t = t.Parent() {\n    fmt.Printf(\"%s (base: %s)\\n\", t.Name(), t.Base())\n}\n\n// Effective values resolve through the chain\ntyp.EffectiveBase()        // underlying base type\ntyp.EffectiveDisplayHint() // first non-empty hint in chain\ntyp.EffectiveEnums()       // first non-empty enum set\n```\n\nClassification helpers: `IsCounter()`, `IsGauge()`, `IsString()`, `IsEnumeration()`, `IsBits()`.\n\n## Notifications\n\n```go\nnotif := m.Notification(\"linkDown\")\n\nnotif.Name()        // \"linkDown\"\nnotif.OID()         // 1.3.6.1.6.3.1.1.5.3\nnotif.Status()      // current\nnotif.Description() // \"A linkDown trap...\"\n\nfor _, obj := range notif.Objects() {\n    fmt.Printf(\"  varbind: %s (%s)\\n\", obj.Name(), obj.OID())\n}\n```\n\nSMIv1 `TRAP-TYPE` definitions populate `TrapInfo()`:\n\n```go\nif trap := notif.TrapInfo(); trap != nil {\n    fmt.Printf(\"enterprise=%s trap-number=%d\\n\", trap.Enterprise, trap.TrapNumber)\n}\n```\n\n## Conformance\n\n`gomib` also exposes `OBJECT-GROUP`, `NOTIFICATION-GROUP`, `MODULE-COMPLIANCE`, and `AGENT-CAPABILITIES`:\n\n```go\ngrp := m.Group(\"ifGeneralInformationGroup\")\ngrp.IsNotificationGroup() // false for OBJECT-GROUP\nfor _, member := range grp.Members() {\n    fmt.Println(member.Name(), member.OID())\n}\n\ncomp := m.Compliance(\"ifCompliance3\")\nfor _, mod := range comp.Modules() {\n    fmt.Println(\"MODULE\", mod.ModuleName) // empty = current module\n    fmt.Println(\"mandatory groups:\", mod.MandatoryGroups)\n}\n\ncap := m.Capability(\"someAgentCaps\")\nif cap != nil {\n    fmt.Println(cap.ProductRelease())\n    for _, sup := range cap.Supports() {\n        fmt.Println(\"SUPPORTS\", sup.ModuleName, sup.Includes)\n    }\n}\n```\n\n## Diagnostics\n\nLoading produces diagnostics for issues found during parsing and resolution.\n\n```go\nm, err := gomib.Load(ctx, gomib.WithSource(src))\n\n// Check for errors\nif m.HasErrors() {\n    fmt.Println(\"errors found\")\n}\n\n// Inspect all diagnostics\nfor _, d := range m.Diagnostics() {\n    fmt.Printf(\"[%s] %s: %s (line %d)\\n\", d.Severity, d.Module, d.Message, d.Line)\n}\n\n// Check unresolved references\nfor _, ref := range m.Unresolved() {\n    fmt.Printf(\"unresolved %s: %s in %s\\n\", ref.Kind, ref.Symbol, ref.Module)\n}\n```\n\n### Strictness and Reporting\n\nResolver strictness controls fallback behavior:\n\n| Resolver strictness | Constant | Behavior |\n|---|---|---|\n| Strict | `ResolverStrict` | Tier 1 only (deterministic scope/import resolution) |\n| Normal | `ResolverNormal` | Tier 1 + Tier 2 (constrained assumptions) |\n| Permissive | `ResolverPermissive` | Tier 1 + Tier 2 + Tier 3 (global search fallbacks) |\n\n```go\nm, _ := gomib.Load(ctx, gomib.WithSource(src), gomib.WithResolverStrictness(mib.ResolverPermissive))\n```\n\nDiagnostic reporting is independent and configured with `WithDiagnosticConfig`:\n\n```go\ngomib.WithDiagnosticConfig(mib.DiagnosticConfig{\n    Reporting: mib.ReportingDefault,\n    FailAt: mib.SeverityError,              // fail on Error or worse\n    Ignore: []string{\"identifier-underscore\"}, // suppress specific codes\n    Overrides: map[string]mib.Severity{\n        \"import-not-found\": mib.SeverityWarning, // downgrade to warning\n    },\n})\n```\n\nCLI equivalents follow the same split:\n\n- `gomib load --strict` and `gomib load --permissive` change resolver behavior.\n- `gomib load --report silent|quiet|default|verbose` changes diagnostic output.\n- `gomib get` and `gomib find` default to permissive resolution with silent reporting.\n- `gomib lint` is separate from resolver strictness and filters diagnostics by severity.\n\n## Syntax and Tokenization\n\nThe `syntax` package provides direct access to the lexer, parser, and concrete syntax tree (CST) for tooling, language servers, linters, or syntax highlighting.\n\n### Tokenization\n\n```go\nimport \"github.com/golangsnmp/gomib/syntax\"\n\nsource := []byte(`ifIndex OBJECT-TYPE SYNTAX InterfaceIndex`)\ntokens := syntax.Tokenize(source)\n\nfor _, tok := range tokens {\n    if tok.Kind == syntax.TokEOF {\n        break\n    }\n    text := source[tok.Span.Start:tok.Span.End]\n    fmt.Printf(\"%-20s %s\\n\", tok.Kind.LibsmiName(), text)\n}\n```\n\nToken kind classification methods on `TokenKind`:\n\n```go\ntok.Kind.IsKeyword()             // any keyword\ntok.Kind.IsMacroKeyword()        // OBJECT-TYPE, MODULE-IDENTITY, etc.\ntok.Kind.IsTypeKeyword()         // INTEGER, Counter32, OCTET, etc.\ntok.Kind.IsClauseKeyword()       // SYNTAX, MAX-ACCESS, STATUS, etc.\ntok.Kind.IsIdentifier()          // uppercase or lowercase identifier\ntok.Kind.IsStructuralKeyword()   // DEFINITIONS, BEGIN, END, IMPORTS, etc.\ntok.Kind.IsStatusAccessKeyword() // current, deprecated, read-only, etc.\n```\n\n### Parsing to CST\n\n`Parse` produces a lossless concrete syntax tree that preserves every byte of the original source, including whitespace and comments. This is useful for tooling that needs structural information without running the full resolution pipeline.\n\n```go\nfile, diags := syntax.Parse(source)\n\nfor _, mod := range file.Modules {\n    name := string(source[mod.Name.Span.Start:mod.Name.Span.End])\n    fmt.Printf(\"module %s: %d definitions\\n\", name, len(mod.Body))\n\n    for _, def := range mod.Body {\n        switch d := def.(type) {\n        case *syntax.ObjectTypeNode:\n            fmt.Printf(\"  OBJECT-TYPE %s\\n\", source[d.Name.Span.Start:d.Name.Span.End])\n        case *syntax.ModuleIdentityNode:\n            fmt.Printf(\"  MODULE-IDENTITY %s\\n\", source[d.Name.Span.Start:d.Name.Span.End])\n        }\n    }\n}\n\n// Round-trip: reconstructing from the CST reproduces the original source exactly\nreconstructed := syntax.ReconstructText(file, source)\n```\n\n### Line tables\n\n`LineTable` provides bidirectional conversion between byte offsets (used by spans) and line/column numbers (used by editors and LSP):\n\n```go\nlt := syntax.BuildLineTable(source)\nline, col := lt.LineCol(tok.Span.Start)       // byte offset -\u003e line/col\noffset, ok := lt.Offset(cursorLine, cursorCol) // line/col -\u003e byte offset\n```\n\n### Span queries on resolved modules\n\nThe resolved model provides span-based queries for language server features like go-to-definition and hover:\n\n```go\nmod := m.Module(\"IF-MIB\")\noffset, ok := mod.Offset(cursorLine, cursorCol) // line/col -\u003e byte offset\nif ok {\n    sc := mod.SpanContext(offset)\n    switch sc.Kind {\n    case mib.SpanContextImport:\n        fmt.Printf(\"import %s from %s\\n\", sc.Name, sc.Module)\n    case mib.SpanContextOidRef:\n        fmt.Printf(\"OID reference to %s\\n\", sc.Name)\n    case mib.SpanContextSyntax:\n        fmt.Printf(\"SYNTAX type %s\\n\", sc.Name)\n    case mib.SpanContextDefinition:\n        fmt.Printf(\"definition %s in %s\\n\", sc.Name, sc.Module)\n    }\n}\n```\n\n## CLI\n\nThe `cmd/gomib` tool provides a command-line interface for MIB operations:\n\n```\ngomib load IF-MIB                    # load and show statistics\ngomib get -m IF-MIB ifIndex          # query by name\ngomib get -m IF-MIB 1.3.6.1.2.1.2   # query by OID\ngomib inspect ifDescr                # deep-dive with type chain, provenance, diagnostics\ngomib dump IF-MIB                    # JSON output\ngomib lint IF-MIB                    # check for issues\ngomib find -p testdata/corpus/primary 'if*'        # search by pattern\ngomib normalize IF-MIB               # emit canonical SMIv2 text\ngomib trace -m IF-MIB ifEntry        # trace resolution\ngomib paths                          # show search paths\ngomib list                           # list available modules\n```\n\nUse `-p PATH` to specify MIB search paths (repeatable). Without `-p`, paths are discovered from net-snmp and libsmi configuration (config files, `MIBDIRS`/`SMIPATH` env vars, standard default directories).\n\nSee [cmd/gomib/README.md](cmd/gomib/README.md) for full command reference.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgolangsnmp%2Fgomib","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgolangsnmp%2Fgomib","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgolangsnmp%2Fgomib/lists"}