Esempio n. 1
0
 def _rowstatus_action(self, session, value):
     if not session:
         raise ValueError, "no session specified"
     if self.rowstatus and self.indexoid:
         vbl = Basetypes.VarBindList()
         vbl.append(Basetypes.VarBind(self.rowstatus.OID+self.indexoid, self.rowstatus.syntaxobject(value)))
         session.set(vbl)
Esempio n. 2
0
 def set(self, session=None, **attribs):
     sess = session or self.session
     vbl = Basetypes.VarBindList()
     for colname, value in attribs.items():
         col = self.columns[colname]
         value = col.syntaxobject(value)
         vbl.append(Basetypes.VarBind(col.OID + self.indexoid, value))
     sess.set(vbl)
Esempio n. 3
0
 def createAndWait(self, session, *indexargs, **attribs):
     vbl = self._create_vbl(*indexargs, **attribs)
     vbl.append(
         Basetypes.VarBind(
             Basetypes.ObjectIdentifier(self.rowstatus.OID + self.indexoid),
             self.rowstatus.syntaxobject(4)))  # create and go
     session.set(vbl)
     return self
Esempio n. 4
0
 def get_values(self, *args):
     sess = self.session
     if sess and self.indexoid:
         rv = []
         vbl = Basetypes.VarBindList()
         cols = map(lambda n: self.columns.get(n), args)
         map(lambda o: vbl.append(Basetypes.VarBind(o.OID+self.indexoid)), cols)
         return_vbl = sess.get_varbindlist(vbl)
         return tuple(map(lambda vb: vb.value, return_vbl))
Esempio n. 5
0
 def _create_vbl(self, *indexargs, **attribs):
     if not self.create:
         raise ValueError, "Cannot create object of type "+self.__class__.__name__
     self.__dict__["indexoid"] = self._make_index_oid(indexargs)
     vbl = Basetypes.VarBindList()
     for key, value in attribs.items():
         colclass = self.columns[key]
         value = colclass.syntaxobject(value)
         vbl.append(Basetypes.VarBind(colclass.OID+self.indexoid, value))
     return vbl
Esempio n. 6
0
 def _make_index_oid(self, indexargs):
     assert len(indexargs) == len(self.index)
     indexoid = Basetypes.ObjectIdentifier()
     i = 0
     for idx in indexargs[:-1]:
         indexoid.extend(Basetypes.oid(self.index[i].syntaxobject(idx)))
         i += 1
     end = self.index[i].syntaxobject(indexargs[-1])
     end.implied = self.index.implied
     indexoid.extend(Basetypes.oid(end))
     return indexoid
Esempio n. 7
0
 def _make_index_oid(self, indexargs):
     assert len(indexargs) == len(self.index)
     indexoid = Basetypes.ObjectIdentifier()
     i = 0
     for idx in indexargs[:-1]:
         indexoid.extend(Basetypes.oid(self.index[i].syntaxobject(idx)))
         i += 1
     end = self.index[i].syntaxobject(indexargs[-1])
     end.implied = self.index.implied
     indexoid.extend(Basetypes.oid(end))
     return indexoid
Esempio n. 8
0
def _decode_a_varbindlist(vbl_tuple):
    vbl = Basetypes.VarBindList()
    for [oid, value] in vbl_tuple:
        obj = _find_object(oid)
        if obj is not None:
            if value is not None:
                if obj.syntaxobject:
                    value = obj.syntaxobject(value)
                if obj.enumerations:
                    value.enumerations = obj.enumerations
            vbl.append(Basetypes.VarBind(oid, value, obj))
        else: # unknown varbind, deal with it later
            vbl.append(Basetypes.VarBind(oid, value))
    return vbl
Esempio n. 9
0
 def genNotifications(self):
     self.fo.write("# notifications (traps) \n")
     for notif in self.smimodule.get_notifications():
         initdict = {"OID": repr(Basetypes.ObjectIdentifier(notif.OID))}
         self.fo.write(genClass(notif, Objects.NotificationObject,
                                initdict))
         self._genOIDItem(notif.OID, notif.name)
Esempio n. 10
0
def decode_oid(length, message):
    """decode ASN.1 object ID"""
    oid = []
    # get the first subid
    subid = ord(message[0])
    oid.append(subid // 40)
    oid.append(subid % 40)

    index = 1
    # loop through the rest
    while index < length:
        # get a subid
        subid = ord(message[index])
        if subid < 128:
            oid.append(subid)
            index = index + 1
        else:
            # construct subid from a number of octets
            next = subid
            subid = 0
            while next >= 128:
                # collect subid
                subid = (subid << 7) + (next & 0x7F)
                # take next octet
                index = index + 1
                next = ord(message[index])
                # just for sure
                if index > length:
                    return bad_integer
            # append a subid to oid list
            subid = (subid << 7) + next
            oid.append(subid)
            index = index + 1
    # return objid
    return Basetypes.OBJECT_IDENTIFIER(oid)
Esempio n. 11
0
 def refresh(self, session=None):
     if (session or self.session) and self.indexoid:
         sess = session or self.session
         vbl = Basetypes.VarBindList()
         map(lambda co: vbl.append(co.varbind.clear()), self.COLUMNS.values())
         return_vbl = sess.get_varbindlist(vbl)
         for vb in return_vbl:
             self.COLUMNS[vb.Object.__name__].set_value(vb.value)
Esempio n. 12
0
 def genNodes(self):
     self.fo.write("# nodes\n")
     for node in self.smimodule.get_nodes(SMI.SMI_NODEKIND_NODE):
         if node.name:
             initdict = {}
             initdict["name"] = repr(node.name)
             initdict["OID"] = repr(Basetypes.ObjectIdentifier(node.OID))
             self.fo.write(genClass(node, Objects.NodeObject, initdict))
             self._genOIDItem(node.OID, node.name)
     self.fo.write("\n")
Esempio n. 13
0
 def genColumns(self):
     self.fo.write("# columns\n")
     for col in self.smimodule.get_columns():
         initdict = {}
         initdict["syntaxobject"] = so = self._getSyntax(col)
         if so.find("Enumeration") >= 0:
             initdict["enumerations"] = col.syntax.enumerations
         initdict["OID"] = repr(Basetypes.ObjectIdentifier(col.OID))
         self.fo.write(genClass(col, Objects.ColumnObject, initdict))
         self.fo.write("\n")
         self._genOIDItem(col.OID, col.name)
Esempio n. 14
0
 def set(self, val, session=None):
     sess = session or self.session
     if self.access != SMI_ACCESS_READ_WRITE:
         raise RuntimeError("Scalar is not writeable")
     val = self.syntaxobject(val)
     try:
         sess.set_varbind(Basetypes.VarBind(self.OID, val))
     except:
         self.value = None
         raise
     else:
         self.value = val
Esempio n. 15
0
 def get(self, session, indexoid=None):
     sess = session or self.session
     if indexoid:
         self.__dict__["indexoid"] = self._make_index_oid(indexoid)
     self.__dict__["COLUMNS"] = {} # clear cache with new dict
     vbl = Basetypes.VarBindList()
     VB = Basetypes.VarBind
     map(lambda o: vbl.append(VB(o.OID+self.indexoid)), self.columns.values())
     return_vbl = sess.get_varbindlist(vbl)
     # insert in COLUMNS
     for vb in return_vbl:
         vbo = vb.Object
         colobj = vbo(vb.value, vb.name[len(vbo.OID)+1:])
         self.add_column(colobj)
     return self
Esempio n. 16
0
 def genScalars(self):
     self.fo.write("# scalars \n")
     for scalar in self.smimodule.get_scalars():
         if scalar.status not in \
                 (SMI.SMI_STATUS_DEPRECATED,
                 SMI.SMI_STATUS_CURRENT,
                 SMI.SMI_STATUS_MANDATORY):
             continue  # do not expose optional or obsolete objects
         initdict = {}
         initdict["syntaxobject"] = so = self._getSyntax(scalar)
         if so.find("Enumeration") >= 0:
             initdict["enumerations"] = scalar.syntax.enumerations
         initdict["OID"] = repr(Basetypes.ObjectIdentifier(scalar.OID))
         self.fo.write(genClass(scalar, Objects.ScalarObject, initdict))
         self.fo.write("\n")
         self._genOIDItem(scalar.OID, scalar.name)
Esempio n. 17
0
 def genGroups(self):
     self.fo.write("# groups \n")
     for group in self.smimodule.get_groups():
         if group.status not in (SMI.SMI_STATUS_CURRENT,
                                 SMI.SMI_STATUS_DEPRECATED,
                                 SMI.SMI_STATUS_MANDATORY):
             continue
         initdict = {}
         initdict["OID"] = repr(Basetypes.ObjectIdentifier(group.OID))
         grouplist = []
         for el in group.get_elements():
             n = el.get_node()
             grouplist.append(n.name)
         initdict["group"] = "[%s]" % ", ".join(grouplist)
         self.fo.write(genClass(group, Objects.GroupObject, initdict))
         self._genOIDItem(group.OID, group.name)
Esempio n. 18
0
 def genRows(self):
     self.fo.write("# rows \n")
     for row in self.smimodule.get_rows():
         if row.status not in (SMI.SMI_STATUS_DEPRECATED,
                     SMI.SMI_STATUS_CURRENT,
                     SMI.SMI_STATUS_MANDATORY):
             continue
         initdict = {}
         columns = "{%s}" % ", ".join(["%r: %s" % (s, s) for s in self._get_colnames(row)])
         initdict["columns"] = columns
         initdict["index"] = self._genIndexObjects(row)
         rowstatus = row.rowstatus
         if rowstatus:
             initdict["rowstatus"] = row.rowstatus.name
         initdict["OID"] = repr(Basetypes.ObjectIdentifier(row.OID))
         self.fo.write(genClass(row, Objects.RowObject, initdict))
         self.fo.write("\n")
Esempio n. 19
0
def decode_timeticks(length, message):
    return Basetypes.TimeTicks(_decode_an_unsigned(length, message))
Esempio n. 20
0
def decode_gauge32(length, message):
    return Basetypes.Gauge32(_decode_an_unsigned(length, message))
Esempio n. 21
0
def decode_endofmibview(length, message):
    return Basetypes.endOfMibView()
Esempio n. 22
0
def decode_nosuchinstance(length, message):
    return Basetypes.noSuchInstance()
Esempio n. 23
0
def decode_unsigned32(length, message):
    return Basetypes.Unsigned32(_decode_an_unsigned(length, message))
Esempio n. 24
0
def decode_v1traprequest(length, message):
    rawpdu = decode_sequence(length, message)
    assert len(rawpdu) == 6
    return Basetypes.SNMPv1TrapPDU(rawpdu[0], rawpdu[1], rawpdu[2], rawpdu[3],
                                   rawpdu[4], _decode_a_varbindlist(rawpdu[5]))
Esempio n. 25
0
 def _oid_(self):
     new = Basetypes.ObjectIdentifier()
     self[-1].implied = self.implied
     for obj in self:
         new.extend(Basetypes.oid(obj))
     return new
Esempio n. 26
0
 def get_scalars(self, *args):
     vbl = Basetypes.VarBindList()
     for o in [self.scalars[on] for on in args]:
         vbl.append(Basetypes.VarBind(o.OID+[0]))
     return_vbl = self.session.get_varbindlist(vbl)
     return tuple([vb.value for vb in return_vbl])
Esempio n. 27
0
def decode_nosuchobject(length, message):
    return Basetypes.noSuchObject()
Esempio n. 28
0
 def varbind(self):
     return Basetypes.VarBind(self.OID, self.value, self.__class__)
Esempio n. 29
0
def decode_ipv4(length, message):
    """decode ASN.1 IP address"""
    assert length == 4
    address = (ord(message[0])<<24) + (ord(message[1])<<16) + \
                    (ord(message[2])<<8) + ord(message[3])
    return Basetypes.IpAddress(address)
Esempio n. 30
0
def decode_counter64(length, message):
    return Basetypes.Counter64(_decode_an_unsigned(length, message))
Esempio n. 31
0
 def _oid_(self):
     new = Basetypes.ObjectIdentifier()
     self[-1].implied = self.implied
     for obj in self:
         new.extend(Basetypes.oid(obj))
     return new
Esempio n. 32
0
 def set(self, value, session=None, indexoid=None):
     if indexoid:
         self.set_index(indexoid)
     sess = session or self.session
     vb = Basetypes.VarBind(self.OID, self.syntaxobject(value))
     return sess.set_varbind(vb)
Esempio n. 33
0
def decode_boolean(length, message):
    return Basetypes.Boolean(ord(message[0]))
Esempio n. 34
0
 def _add_vb(self, vb):
     prefixlen = self.prefixlen
     col = Basetypes.OID(vb.oid[prefixlen:prefixlen + 1])
     row = Basetypes.OID(vb.oid[prefixlen + 1:])
     #self.add_by_name(col, row, vb.value)
     self.set(str(col), str(row), vb.value)  # XXX
Esempio n. 35
0
 def _add_vb(self, vb):
     prefixlen = len(self.OID)
     col = Basetypes.OID(vb.oid[prefixlen:prefixlen+1])
     row = Basetypes.OID(vb.oid[prefixlen+1:])
     self.add_by_name(col, row, vb.value)