def _initialize_engine(self):
self.transport_dispatcher = AsyncoreDispatcher()
self.transport_dispatcher.registerRecvCbFun(self._receive_and_save)
self.transport_dispatcher.registerTransport(
self.udp_domain_name,
self.udp_socket_transport().openServerMode(
(self.snmp_host, self.snmp_host_port)))
self.transport_dispatcher.jobStarted(1)
def __init__(self, pdu, listen_address, listen_port, community="public"):
super(SNMPPDUHarness, self).__init__()
self.logger = logging.getLogger(__name__)
self.pdu = pdu
self.snmp_handler = SNMPPDUHandler(self.pdu, community=community)
self.listen_address = listen_address
self.listen_port = listen_port
self.transportDispatcher = AsyncoreDispatcher()
def init_new_dispatcher(self, id_src):
self.dict_dispatchers[id_src] = AsyncoreDispatcher()
self.dict_dispatchers_locks[id_src] = _thread.allocate_lock()
self.dict_dispatchers[id_src].registerRecvCbFun(self.cbRecvFun)
self.dict_dispatchers[id_src].registerTransport(udp.domainName, udp.UdpSocketTransport().openClientMode())
self.dict_dispatchers[id_src].jobStarted(1)
def __init__(self, pdu, listen_address, listen_port, community="public"):
super(SNMPPDUHarness, self).__init__()
self.logger = logging.getLogger(__name__)
self.pdu = pdu
self.snmp_handler = SNMPPDUHandler(self.pdu, community=community)
self.listen_address = listen_address
self.listen_port = listen_port
self.transportDispatcher = AsyncoreDispatcher()
self._lock = threading.Lock()
self._stop_requested = False
elif errorStatus:
print('Notification Receiver returned error for request %s, '
'SNMP Engine %s: %s @%s' % (sendRequestHandle,
snmpEngine.snmpEngineID.prettyPrint(),
errorStatus, errorIndex))
else:
print('Notification %s for SNMP Engine %s delivered: ' % (
sendRequestHandle, snmpEngine.snmpEngineID.prettyPrint()))
for name, val in varBinds:
print('%s = %s' % (name.prettyPrint(), val.prettyPrint()))
# Instantiate the single transport dispatcher object
transportDispatcher = AsyncoreDispatcher()
# Setup a custom data routing function to select snmpEngine by transportDomain
transportDispatcher.registerRoutingCbFun(
lambda td, ta, d: ta[1] % 3 and 'A' or 'B'
)
snmpEngineA = SnmpEngine()
snmpEngineA.registerTransportDispatcher(transportDispatcher, 'A')
snmpEngineB = SnmpEngine()
snmpEngineB.registerTransportDispatcher(transportDispatcher, 'B')
for authData, transportTarget, contextData in TARGETS:
# Pick one of the two SNMP engines
def __init__(self, usage=False):
# abort if pysnmp is not installed
if not snmp_modules_found:
output().warning_(
"Please install the 'pysnmp' module for SNMP support.")
if usage: print("")
return
# skip when running 'discover' in interactive mode
if usage: print("No target given, discovering local printers")
oid = (
('1.3.6.1.2.1.25.3.2.1.2.1',
None), # HOST-RESOURCES-MIB → hrDeviceType
('1.3.6.1.2.1.25.3.2.1.3.1',
None), # HOST-RESOURCES-MIB → hrDeviceDescr
('1.3.6.1.2.1.25.3.2.1.5.1',
None), # HOST-RESOURCES-MIB → hrDeviceStatus
('1.3.6.1.2.1.43.16.5.1.2.1.1',
None), # Printer-MIB → Printer status
('1.3.6.1.2.1.1.3.0', None)) # SNMPv2-MIBv → sysUpTime
try:
# build protocol data unit (pdu)
pmod.apiPDU.setDefaults(pdu_send)
pmod.apiPDU.setVarBinds(pdu_send, oid)
# build message
msg_send = pmod.Message()
pmod.apiMessage.setDefaults(msg_send)
pmod.apiMessage.setCommunity(msg_send, 'public')
pmod.apiMessage.setPDU(msg_send, pdu_send)
# ...
dispatcher = AsyncoreDispatcher()
dispatcher.registerRecvCbFun(recv)
dispatcher.registerTimerCbFun(timer)
# use ipv4 udp broadcast
udpSocketTransport = udp.UdpSocketTransport().openClientMode(
).enableBroadcast()
dispatcher.registerTransport(udp.domainName, udpSocketTransport)
# pass message to dispatcher
target = ('255.255.255.255', 161)
dispatcher.sendMessage(encoder.encode(msg_send), udp.domainName,
target)
# wait for timeout or max hosts
dispatcher.jobStarted(1, maxhost)
# dispatcher will finish as all jobs counter reaches zero
try:
dispatcher.runDispatcher()
except stop_waiting:
dispatcher.closeDispatcher()
# list found network printers
if results:
print("")
output().discover_(
('address', ('device', 'uptime', 'status', None)))
output().hline_(79)
for printer in sorted(
results.items(),
key=lambda item: socket.inet_aton(item[0])):
output().discover_(printer)
else:
output().info_("No printers found via SNMP broadcast")
if usage or results: print("")
except Exception as e:
output().errmsg_("SNMP Error", e)
if usage: print("")
def mock_add_transport(snmpEngine, transportDomain, transport):
snmpEngine.transportDispatcher = AsyncoreDispatcher()
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(reqPDU) == pMod.apiPDU.getRequestID(
rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
('192.168.1.88', 161))
transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(reqPDU) == pMod.apiPDU.getRequestID(
rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# Initialize UDP/IPv4 transport
udpSocketTransport = udp.UdpSocketTransport().openClientMode()
# Use sendmsg()/recvmsg() for socket communication (required for
# IP source spoofing functionality)
udpSocketTransport.enablePktInfo()
# Enable IP source spoofing (requires root privileges)
udpSocketTransport.enableTransparent()
transportDispatcher.registerTransport(udp.domainName, udpSocketTransport)
def __init__(self, data, timeout_func=None, receive_func=None, error_func=None):
self.__dict__.update(data)
self.timeout_func = timeout_func
self.receive_func = receive_func
self.error_func = error_func
headVars = [v2c.ObjectIdentifier(oid) for oid in
map(lambda oid: (int(i) for i in oid.split('.')), self.oid_keys)]
self.reqPDU = reqPDU = v2c.GetBulkRequestPDU()
v2c.apiBulkPDU.setDefaults(reqPDU)
v2c.apiBulkPDU.setNonRepeaters(reqPDU, self.non_repeaters)
v2c.apiBulkPDU.setMaxRepetitions(reqPDU, self.max_repetitions)
v2c.apiBulkPDU.setVarBinds(reqPDU, [(x, v2c.null) for x in headVars])
reqMsg = v2c.Message()
v2c.apiMessage.setDefaults(reqMsg)
v2c.apiMessage.setCommunity(reqMsg, self.community)
v2c.apiMessage.setPDU(reqMsg, reqPDU)
self.startedAt = time()
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(self.cbRecvFun)
transportDispatcher.registerTimerCbFun(self.cbTimerFun)
transportDispatcher.registerTransport(udp.domainName, udp.UdpSocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName, (self.network_address, self.port))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
print('INFORM message delivered, response var-binds follow')
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.DOMAIN_NAME, udp.UdpSocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(trapMsg), udp.DOMAIN_NAME, ('demo.snmplabs.com', 162)
)
transportDispatcher.jobStarted(1)
# UDP/IPv6
# transportDispatcher.registerTransport(
if msgVer == api.protoVersion1:
print('Enterprise: %s' % (pMod.apiTrapPDU.getEnterprise(reqPDU).prettyPrint()))
print('Agent Address: %s' % (pMod.apiTrapPDU.getAgentAddr(reqPDU).prettyPrint()))
print('Generic Trap: %s' % (pMod.apiTrapPDU.getGenericTrap(reqPDU).prettyPrint()))
print('Specific Trap: %s' % (pMod.apiTrapPDU.getSpecificTrap(reqPDU).prettyPrint()))
print('Uptime: %s' % (pMod.apiTrapPDU.getTimeStamp(reqPDU).prettyPrint()))
varBinds = pMod.apiTrapPDU.getVarBindList(reqPDU)
else:
varBinds = pMod.apiPDU.getVarBindList(reqPDU)
print('Var-binds:')
for oid, val in varBinds:
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode((IPADDR, PORT))
)
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
def __init__(self, data, timeout_func=None, receive_func=None, error_func=None):
self.__dict__.update(data)
self.timeout_func = timeout_func
self.receive_func = receive_func
self.error_func = error_func
self.pMod = pMod = api.protoModules[api.protoVersion2c]
self.reqPDU = reqPDU = pMod.GetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU, ((oid, pMod.Null('')) for oid in self.oid_keys))
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
self.startedAt = time()
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(self.cbRecvFun)
transportDispatcher.registerTimerCbFun(self.cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(udp.domainName, udp.UdpSocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName, (self.network_address, self.port))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
udpSocketTransport = udp.UdpSocketTransport().openClientMode().enableBroadcast()
transportDispatcher.registerTransport(udp.DOMAIN_NAME, udpSocketTransport)
# Pass message to dispatcher
transportDispatcher.sendMessage(
encoder.encode(reqMsg), udp.DOMAIN_NAME, ('255.255.255.255', 161)
)
# wait for a maximum of 10 responses or time out
transportDispatcher.jobStarted(1, maxNumberResponses)
"""#
from pysnmp.entity import engine, config
from pysnmp.entity.rfc3413 import cmdrsp, context
from pysnmp.proto import rfc1902
from pysnmp.carrier.asyncore.dispatch import AsyncoreDispatcher
from pysnmp.carrier.asyncore.dgram import udp
# Configuration parameters for each of SNMP Engines
snmpEngineInfo = (('0102030405060708', udp.domainName + (0, ),
('127.0.0.1', 161)), ('0807060504030201',
udp.domainName + (1, ), ('127.0.0.2',
161)))
# Instantiate the single transport dispatcher object
transportDispatcher = AsyncoreDispatcher()
# Setup a custom data routing function to select snmpEngine by transportDomain
transportDispatcher.registerRoutingCbFun(lambda td, t, d: td)
# Instantiate and configure SNMP Engines
for snmpEngineId, transportDomain, transportAddress in snmpEngineInfo:
# Create SNMP engine with specific engineID
snmpEngine = engine.SnmpEngine(rfc1902.OctetString(hexValue=snmpEngineId))
# Register SNMP Engine object with transport dispatcher. Request incoming
# data from specific transport endpoint to be funneled to this SNMP Engine.
snmpEngine.registerTransportDispatcher(transportDispatcher,
transportDomain)
# Transport setup
def run_dispatcher(conf):
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(callback)
for num, cfg_string in enumerate(conf.alerts_interfaces):
parsed = cfg_string.split(':')
address = (parsed[0], int(parsed[1]) if len(parsed) == 2 else 162)
transportDispatcher.registerTransport(
udp.domainName + (num + 1, ),
udp.UdpSocketTransport().openServerMode(address))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
# Generate request for next row
v2c.apiBulkPDU.setVarBinds(
reqPDU, [(x, v2c.null) for x, y in varBindTable[-1]]
)
v2c.apiBulkPDU.setRequestID(reqPDU, v2c.getNextRequestID())
transportDispatcher.sendMessage(
encoder.encode(reqMsg), transportDomain, transportAddress
)
global startedAt
if time() - startedAt > 3:
raise Exception('Request timed out')
startedAt = time()
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(reqMsg), udp.domainName, (input('Enter Host: '), 161)
)
transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
transportDispatcher.runDispatcher()
key='.'.join([str(i) for i in v._value])
value=b.getComponent('simple')._value
parsed=ObjectType(ObjectIdentity(key), value)
try: parsed.resolveWithMib(viewController)
except Exception as e:
logger.warning("TRAP\tERROR | Failed to resolve symbol ({}={})".format(key,value))
continue
key,value=parsed.prettyPrint().split(" = ")
logger.info("TRAP\t{} | {}".format(key,value))
if key=="PowerNet-MIB::mtrapargsString.0":
message=value
for contact in contacts['contacts']:
phoneNumber=contact['phoneNumber']
_redis.publish('sms', json.dumps(dict(phoneNumber=phoneNumber, message=message)))
return msg
dispatcher=AsyncoreDispatcher()
dispatcher.registerRecvCbFun(snmpRecvCallback)
dispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode((TRAP_IP_ADDRESS, TRAP_PORT))
)
dispatcher.jobStarted(1)
print("Starting...")
try: dispatcher.runDispatcher()
except:
dispatcher.closeDispatcher()
raise
def __init__(self):
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(self.cbFun)
transportDispatcher.registerTransport(udp.domainName, udp.UdpSocketTransport().openServerMode(('192.168.1.111', 162))) #RASPBERRY / PC IP ADRESS
transportDispatcher.jobStarted(1)
try:
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
def __init__(self, data, timeout_func=None, receive_func=None, error_func=None):
self.__dict__.update(data)
self.timeout_func = timeout_func
self.receive_func = receive_func
self.error_func = error_func
self.pMod = pMod = api.protoModules[api.protoVersion2c]
self.reqPDU = reqPDU = pMod.SetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU,
map(lambda a: (a[0], pMod.OctetString(str(a[2]))) if a[1] == 'str'
else (a[0], pMod.Integer(int(a[2]))), self.oid_keys_enc_val))
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
self.startedAt = time()
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(self.cbRecvFun)
transportDispatcher.registerTimerCbFun(self.cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(udp.domainName, udp.UdpSocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName, (self.network_address, self.port))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
def GEToutlet(self, outlet=None, IP=None):
if IP == None:
IP = self.ip
pMod = api.protoModules[api.protoVersion1]
# pMod = api.protoModules[api.protoVersion2c]
# Build PDU
reqPDU = pMod.GetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU, (
(self.command['name'], pMod.Null('')),
(self.command['port'], pMod.Null('')),
(self.command['name_1'], pMod.Null('')),
(self.command['name_2'], pMod.Null('')),
(self.command['name_3'], pMod.Null('')),
(self.command['name_4'], pMod.Null('')),
(self.command['name_5'], pMod.Null('')),
(self.command['name_6'], pMod.Null('')),
(self.command['name_7'], pMod.Null('')),
(self.command['name_8'], pMod.Null('')),
))
# Build message
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 3:
raise Exception("Request timed out")
# noinspection PyUnusedLocal,PyUnusedLocal
def cbRecvFun(transportDispatcher=None,
transportDomain=None,
transportAddress=None,
wholeMsg=None,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
oid_str = oid.prettyPrint()
if oid_str == '1.3.6.1.4.1.318.1.1.4.2.2.0':
self.result_str = val.prettyPrint()
elif oid_str == self.command['name_1']:
self.nothing = []
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_2']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_3']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_4']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_5']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_6']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_7']:
self.nothing.append(val.prettyPrint())
elif oid_str == self.command['name_8']:
self.nothing.append(val.prettyPrint())
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(IP, 161))
transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
transportDispatcher.runDispatcher()
self.nothing = self.nothing + [
'...',
'...',
'...',
'...',
'...',
'...',
'...',
'...',
]
#print self.nothing
result_str = self.result_str.split()
for i, element in enumerate(result_str):
result_str[i] = '%d--%s--%s' % (i + 1, self.nothing[i],
result_str[i])
if outlet == None:
for i in range(len(result_str)):
print result_str[i]
else:
try:
for j in outlet:
print result_str[int(j) - 1]
except:
print 'One outlet dosen\'t exist. Please check your input.'
transportDispatcher.closeDispatcher()
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg, asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(reqPDU)==pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# Initialize UDP/IPv4 transport
udpSocketTransport = udp.UdpSocketTransport().openClientMode()
# Use sendmsg()/recvmsg() for socket communication (required for
# IP source spoofing functionality)
udpSocketTransport.enablePktInfo()
# Enable IP source spoofing (requires root privileges)
udpSocketTransport.enableTransparent()
transportDispatcher.registerTransport(udp.domainName, udpSocketTransport)
def GETcurrent(self, IP=None):
if IP == None:
IP = self.ip
pMod = api.protoModules[api.protoVersion1]
# Build PDU
reqPDU = pMod.GetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU,
((self.command['current'], pMod.Null('')), ))
# Build message
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 3:
raise Exception("Request timed out")
# noinspection PyUnusedLocal,PyUnusedLocal
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
oid_str = oid.prettyPrint()
if oid_str == '1.3.6.1.4.1.318.1.1.12.2.3.1.1.2.1':
print('%s' % (val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(IP, 161))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
def action(self, outlet, action, IP=None):
'''Set parameter for PDU.'''
if IP == None:
IP = self.ip
# Protocol version to use
pMod = api.protoModules[api.protoVersion1]
# Build PDU
reqPDU = pMod.SetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
outlet = str(outlet)
pMod.apiPDU.setVarBinds(reqPDU,
((self.command['outlet_header'] + outlet,
pMod.Integer(self.action_dict[action])), ))
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 2:
raise Exception("Request timed out")
# noinspection PyUnusedLocal,PyUnusedLocal
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print '-----OK-----'
#print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(IP, 161))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
while wholeMsg:
rspMsg,wholeMsg = decoder.decode(wholeMsg,asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(reqMsg)
if pMod.apiPDU.getRequestID(reqPDU)==pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openClientMode()
)
# Pass message to dispatcher
transportDispatcher.sendMessage(
encoder.encode(reqMsg), udp.domainName, ('localhost', 1161)
)
transportDispatcher.jobStarted(1)
def run_dispatcher(conf):
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(callback)
for num, cfg_string in enumerate(conf.alerts_interfaces):
parsed = cfg_string.split(':')
address = (parsed[0], int(parsed[1]) if len(parsed) == 2 else 162)
transportDispatcher.registerTransport(
udp.domainName + (num + 1,),
udp.UdpSocketTransport().openServerMode(address))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
def listenForTraps(self):
asyncF = asyncFunc()
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(asyncF.cbFun)
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode((self.SNMP_HOST, self.SNMP_PORT))
)
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
finally:
transportDispatcher.closeDispatcher()
class SNMPPDUHarness(threading.Thread):
def __init__(self, pdu, listen_address, listen_port, community="public"):
super(SNMPPDUHarness, self).__init__()
self.logger = logging.getLogger(__name__)
self.pdu = pdu
self.snmp_handler = SNMPPDUHandler(self.pdu, community=community)
self.listen_address = listen_address
self.listen_port = listen_port
self.transportDispatcher = AsyncoreDispatcher()
def run(self):
self.logger.info("Starting PDU '{}' on {}:{}".format(
self.pdu.name, self.listen_address, self.listen_port))
self.transportDispatcher.registerRecvCbFun(
self.snmp_handler.message_handler)
# UDP/IPv4
self.transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
(self.listen_address, self.listen_port)))
self.transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
self.transportDispatcher.runDispatcher()
except Exception:
self.transportDispatcher.closeDispatcher()
def stop(self):
self.transportDispatcher.jobFinished(1)
def _read(self, keys, IP=None):
'''read results for keys.
keys is a list.
'''
if IP == None:
IP = self.ip
values = []
pMod = api.protoModules[api.protoVersion1]
# pMod = api.protoModules[api.protoVersion2c]
# Build PDU
reqPDU = pMod.GetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
###
pMod.apiPDU.setVarBinds(reqPDU, zip(keys, [pMod.Null('')] * len(keys)))
# Build message
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 3:
raise Exception('Request timed out')
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
values.append(val.prettyPrint())
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(IP, 161))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
return values
def snmpgetint(self, host, check):
global checkname
global hostname
global res
try:
print('doing ' + check + ' on ' + host)
hostname = Hosts.objects.get(name=host)
if hostname.enabled is True:
checkname = HostChecks.objects.get(name=check)
address = hostname.address
community = hostname.community
oid = checkname.arg
# res = str(float(snmp_get(oid, hostname=address, community=community, version=1).value) * float(check.quotient))
# from pysnmp import debug
# debug.setLogger(debug.Debug('msgproc'))
# Protocol version to use
pMod = api.protoModules[api.protoVersion1]
# pMod = api.protoModules[api.protoVersion2c]
# Build PDU
reqPDU = pMod.GetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU, (((oid), pMod.Null()), ))
# Build message
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 3:
raise Exception("Request timed out")
# noinspection PyUnusedLocal,PyUnusedLocal
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
# print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
# res = str(float(val.prettyPrint() * float(check.quotient)))
global checkname
global hostname
global res
res = str(
float(val * float(checkname.quotient)))
computeint(checkname, hostname, res)
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
# transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg),
udp.domainName, (address, 161))
transportDispatcher.jobStarted(1)
## UDP/IPv6 (second copy of the same PDU will be sent)
# transportDispatcher.registerTransport(
# udp6.domainName, udp6.Udp6SocketTransport().openClientMode()
# )
# Pass message to dispatcher
# transportDispatcher.sendMessage(
# encoder.encode(reqMsg), udp6.domainName, ('::1', 161)
# )
# transportDispatcher.jobStarted(1)
## Local domain socket
# transportDispatcher.registerTransport(
# unix.domainName, unix.UnixSocketTransport().openClientMode()
# )
#
# Pass message to dispatcher
# transportDispatcher.sendMessage(
# encoder.encode(reqMsg), unix.domainName, '/tmp/snmp-agent'
# )
# transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
# print(transportDispatcher)
del transportDispatcher
del pMod
del reqPDU
del reqMsg
del startedAt
del cbTimerFun
del cbRecvFun
# computeint(check, host, res)
# print(oid + ' on ' + address + ' equals ' + res)
except Exception as e:
print('doing ' + checkname.name + ' on ' + hostname.name + ' failed')
print(traceback.format_exc())
# update the error count
setMetadata(hostname.name + ':' + checkname.name + '::lasterror',
str(timezone.now()))
setMetadata(
hostname.name + ':' + checkname.name + '::nberror',
int(
getMetadata(hostname.name + ':' + checkname.name + '::nberror',
0)) + 1)
# Log the error to the database.
ErrorLog(hostcheck=checkname,
host=hostname,
event=e.__class__.__name__,
error=str(e),
value=res).save()
return res
def _write(self, keys, values, IP=None):
'''Write keys and values to PDU.
keys and values are lists of the same length. Example:
keys = ['1.3.6.1.4.1.318.1.1.4.5.2.1.3.1',]
values = [1,]
'''
if len(keys) != len(values):
print 'Error: the keys and values are not matched.'
exit()
if IP == None:
IP = self.ip
# Protocol version to use
pMod = api.protoModules[api.protoVersion1]
# Build PDU
reqPDU = pMod.SetRequestPDU()
pMod.apiPDU.setDefaults(reqPDU)
pMod.apiPDU.setVarBinds(reqPDU, zip(keys, map(pMod.Integer, values)))
reqMsg = pMod.Message()
pMod.apiMessage.setDefaults(reqMsg)
pMod.apiMessage.setCommunity(reqMsg, self.community)
pMod.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time()
def cbTimerFun(timeNow):
if timeNow - startedAt > 3:
raise Exception('Request timed out')
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg,
asn1Spec=pMod.Message())
rspPDU = pMod.apiMessage.getPDU(rspMsg)
# Match response to request
if pMod.apiPDU.getRequestID(
reqPDU) == pMod.apiPDU.getRequestID(rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
#print '-----OK-----'
pass
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
# Pass message to dispatcher
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(IP, 161))
transportDispatcher.jobStarted(1)
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
def SnmpwalkAsync(target_IP=None,
oid=None,
community='public',
walk_timeout=10,
mode='ipv4'):
"""Script to run in the remote device for snmp mib walk.
This script can be copied to the remote device eg:wan
and can be executed directly using python for snmp mib walk
The walk can done for both ipv6 and ipv4
:param target_IP: device IP for mib query
:type target_IP: string
:param oid: mib query OID
:type oid: string
:param community: community string for mib query, defaults to public
:type community: string, optional
:param walk_timeout: snmp walk timeout, defaults to 10
:type walk_timeout: integer, optional
:param mode: mib query mode, defaults to ipv4
:type mode: string, optional
:return: mib query output
:rtype: string
"""
# SNMP table header
headVars = [v2c.ObjectIdentifier((oid))]
# Build PDU
reqPDU = v2c.GetBulkRequestPDU()
v2c.apiBulkPDU.setDefaults(reqPDU)
v2c.apiBulkPDU.setNonRepeaters(reqPDU, 0)
v2c.apiBulkPDU.setMaxRepetitions(reqPDU, 25)
v2c.apiBulkPDU.setVarBinds(reqPDU, [(x, v2c.null) for x in headVars])
# Build message
reqMsg = v2c.Message()
v2c.apiMessage.setDefaults(reqMsg)
v2c.apiMessage.setCommunity(reqMsg, community)
v2c.apiMessage.setPDU(reqMsg, reqPDU)
startedAt = time.time()
output_list = []
def cbTimerFun(timeNow):
# Duration
if timeNow - startedAt > walk_timeout:
if walk_timeout != 0:
raise Exception("Request timed out")
else:
if timeNow - startedAt > 30:
transportDispatcher.jobFinished(1)
# noinspection PyUnusedLocal
def cbRecvFun(transportDispatcher,
transportDomain,
transportAddress,
wholeMsg,
reqPDU=reqPDU,
headVars=headVars):
while wholeMsg:
rspMsg, wholeMsg = decoder.decode(wholeMsg, asn1Spec=v2c.Message())
rspPDU = v2c.apiMessage.getPDU(rspMsg)
# Match response to request
if v2c.apiBulkPDU.getRequestID(
reqPDU) == v2c.apiBulkPDU.getRequestID(rspPDU):
# Format var-binds table
varBindTable = v2c.apiBulkPDU.getVarBindTable(reqPDU, rspPDU)
# Check for SNMP errors reported
errorStatus = v2c.apiBulkPDU.getErrorStatus(rspPDU)
if errorStatus and errorStatus != 2:
errorIndex = v2c.apiBulkPDU.getErrorIndex(rspPDU)
print('%s at %s' %
(errorStatus.prettyPrint(), errorIndex
and varBindTable[int(errorIndex) - 1] or '?'))
transportDispatcher.jobFinished(1)
break
# Report SNMP table
for tableRow in varBindTable:
for name, val in tableRow:
# print mib data
print('from: %s, %s = %s' %
(transportAddress, name.prettyPrint(),
val.prettyPrint()))
output_list.append(
'from: %s, %s = %s\n' %
(transportAddress, name.prettyPrint(),
val.prettyPrint()))
# Stop on EOM
for oid, val in varBindTable[-1]:
if not isinstance(val, v2c.Null):
break
else:
transportDispatcher.jobFinished(1)
# Generate request for next row
v2c.apiBulkPDU.setVarBinds(reqPDU,
[(x, v2c.null)
for x, y in varBindTable[-1]])
v2c.apiBulkPDU.setRequestID(reqPDU, v2c.getNextRequestID())
transportDispatcher.sendMessage(encoder.encode(reqMsg),
transportDomain,
transportAddress)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
if mode == 'ipv4':
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(reqMsg), udp.domainName,
(target_IP, 161))
else:
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(reqMsg),
udp6.domainName, (target_IP, 161))
transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
if output_list != []:
return output_list
else:
return
def main():
logging.basicConfig(filename='traps.log',
filemode='w',
level=logging.ERROR,
format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p')
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162)))
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(('::1', 162)))
## Local domain socket
# transportDispatcher.registerTransport(
# unix.domainName, unix.UnixSocketTransport().openServerMode('/tmp/snmp-manager')
# )
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
# Report unsupported request type
pMod.apiPDU.setErrorStatus(rspPDU, 'genErr')
pMod.apiPDU.setVarBinds(rspPDU, varBinds)
# Commit possible error indices to response PDU
for f, i in pendingErrors:
f(rspPDU, i)
transportDispatcher.sendMessage(encoder.encode(rspMsg),
transportDomain, transportAddress)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.DOMAIN_NAME,
udp.UdpSocketTransport().openServerMode(('localhost', 161)))
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.DOMAIN_NAME,
udp6.Udp6SocketTransport().openServerMode(('::1', 161)))
transportDispatcher.jobStarted(1)
try:
def escucharTrap():
print("Escucho")
# se queda escuchando, lanza callback (cb) cuando recibe paquyete
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162)))
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(('::1', 162)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
(pMod.apiPDU.setNoSuchInstanceError, errorIndex)
)
break
else:
# Report unsupported request type
pMod.apiPDU.setErrorStatus(rspPDU, 'genErr')
pMod.apiPDU.setVarBinds(rspPDU, varBinds)
# Commit possible error indices to response PDU
for f, i in pendingErrors:
f(rspPDU, i)
transportDispatcher.sendMessage(
encoder.encode(rspMsg), transportDomain, transportAddress
)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(('localhost', 1161))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(('::1', 1161))
)
## Local domain socket
#transportDispatcher.registerTransport(
# unix.domainName, unix.UnixSocketTransport().openServerMode('/tmp/snmp-agent')
print('Specific Trap: %s' % (pMod.apiTrapPDU.getSpecificTrap(reqPDU).prettyPrint()))
print('Uptime: %s' % (pMod.apiTrapPDU.getTimeStamp(reqPDU).prettyPrint()))
varBinds = pMod.apiTrapPDU.getVarBinds(reqPDU)
else:
varBinds = pMod.apiPDU.getVarBinds(reqPDU)
print('Var-binds:')
for oid, val in varBinds:
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.DOMAIN_NAME, udp.UdpSocketTransport().openServerMode(('localhost', 162))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.DOMAIN_NAME, udp6.Udp6SocketTransport().openServerMode(('::1', 162))
)
transportDispatcher.jobStarted(1)
def openServer():
print "In Open server mode"
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(newFn)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(('localhost', 1171))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(('::1', 1171))
)
transportDispatcher.jobStarted(1)
print "job started"
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
def run(self):
super(SnmpParsingService, self).run()
LOG.info("Vitrage SNMP Parsing Service - Starting...")
transport_dispatcher = AsyncoreDispatcher()
transport_dispatcher.registerRecvCbFun(self.callback_func)
trans_udp = udp.UdpSocketTransport()
udp_transport = \
trans_udp.openServerMode(('0.0.0.0', self.listening_port))
trans_udp6 = udp6.Udp6SocketTransport()
udp6_transport = \
trans_udp6.openServerMode(('::1', self.listening_port))
transport_dispatcher.registerTransport(udp.domainName, udp_transport)
transport_dispatcher.registerTransport(udp6.domainName, udp6_transport)
LOG.info("Vitrage SNMP Parsing Service - Started!")
transport_dispatcher.jobStarted(self.RUN_FOREVER)
try:
transport_dispatcher.runDispatcher()
except Exception:
LOG.error("Run transport dispatcher failed.")
transport_dispatcher.closeDispatcher()
raise
class TrapEngine:
"""
This trap engine core class implements all the required behaviour for SNMP traps.
Constructor Positional Arguments:
- snmp_host -- destination IP address for SNMP traps
- snmp_port -- destination UDP port address for SNMP traps
- snmp_config -- SNMP configuration details for accessing device
"""
def __init__(self, snmp_host, snmp_host_port, session_parameters):
self.snmp_host = snmp_host
self.snmp_host_port = snmp_host_port
self.session_parameters = session_parameters
self.udp_domain_name = udp.domainName
self.udp_socket_transport = udp.UdpSocketTransport
self.trap_model_parameters = dict()
def _receive_and_save(self, transportDispatcher, transportDomain,
transportAddress, wholeMsg):
while wholeMsg:
msgVer = int(api.decodeMessageVersion(wholeMsg))
if msgVer in api.protoModules:
pMod = api.protoModules[msgVer]
else:
logging.warning('Unsupported SNMP version %s' % msgVer)
return
reqMsg, wholeMsg = decoder.decode(
wholeMsg,
asn1Spec=pMod.Message(),
)
logging.warning('########## RECEIVED NEW TRAP ########## ')
logging.warning(
f'Notification message from {transportDomain}:{transportAddress}'
)
reqPDU = pMod.apiMessage.getPDU(reqMsg)
if reqPDU.isSameTypeWith(pMod.TrapPDU()):
trap_date = datetime.now()
trap_date = trap_date.replace(hour=datetime.now().hour + 1)
trap_date = trap_date.strftime("%m/%d/%Y, %H:%M:%S")
trap_domain = transportDomain
trap_address = transportAddress[0]
trap_port = transportAddress[1]
logging.warning(f'Datetime: {trap_date}')
logging.warning(f'Trap Domain: {trap_domain}')
logging.warning(f'Agent Address: {trap_address}:{trap_port}')
full_system_name = self._get_system_name(trap_address)
device_model = DeviceModel.objects.get(
full_system_name=full_system_name)
self.trap_model_parameters = dict(device_model=device_model,
trap_domain=trap_domain,
trap_address=trap_address,
trap_port=trap_port,
trap_date=trap_date)
varBinds = pMod.apiTrapPDU.getVarBinds(reqPDU)
if not self._database_validator():
trap_model = DeviceTrapModel(**self.trap_model_parameters)
trap_model.save()
for trap_oid, trap_data in varBinds:
var_bids_parameters = {
'trap_model': trap_model,
'trap_oid': trap_oid,
'trap_data': trap_data
}
var_bids_model = VarBindModel(**var_bids_parameters)
var_bids_model.save()
else:
varBinds = pMod.apiPDU.getVarBinds(reqPDU)
logging.warning('Var-binds:')
for oid, val in varBinds:
logging.warning('%s = %s' % (oid, val))
return wholeMsg
def _database_validator(self):
return DeviceTrapModel.objects.filter(
device_model=self.trap_model_parameters['device_model'],
trap_domain=self.trap_model_parameters['trap_domain'],
trap_address=self.trap_model_parameters['trap_address'],
trap_port=self.trap_model_parameters['trap_port'],
trap_date=self.trap_model_parameters['trap_date']).exists()
def _get_system_name(self, trap_address):
self.session_parameters['hostname'] = trap_address
session = Session(**self.session_parameters)
full_system_name = session.walk('sysName')[0].value
return full_system_name
def _initialize_engine(self):
self.transport_dispatcher = AsyncoreDispatcher()
self.transport_dispatcher.registerRecvCbFun(self._receive_and_save)
self.transport_dispatcher.registerTransport(
self.udp_domain_name,
self.udp_socket_transport().openServerMode(
(self.snmp_host, self.snmp_host_port)))
self.transport_dispatcher.jobStarted(1)
def run_engine(self):
self._initialize_engine()
self.transport_dispatcher.runDispatcher()
def close_engine(self):
self.transport_dispatcher.closeDispatcher()
def main():
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument('-v',
'--version',
action='version',
version=utils.TITLE)
parser.add_argument('--quiet',
action='store_true',
help='Do not print out informational messages')
parser.add_argument(
'--debug',
choices=pysnmp_debug.flagMap,
action='append',
type=str,
default=[],
help='Enable one or more categories of SNMP debugging.')
parser.add_argument(
'--debug-asn1',
choices=pyasn1_debug.FLAG_MAP,
action='append',
type=str,
default=[],
help='Enable one or more categories of ASN.1 debugging.')
parser.add_argument('--logging-method',
type=lambda x: x.split(':'),
metavar='=<%s[:args]>]' % '|'.join(log.METHODS_MAP),
default='stderr',
help='Logging method.')
parser.add_argument('--log-level',
choices=log.LEVELS_MAP,
type=str,
default='info',
help='Logging level.')
parser.add_argument('--reporting-method',
type=lambda x: x.split(':'),
metavar='=<%s[:args]>]' %
'|'.join(ReportingManager.REPORTERS),
default='null',
help='Activity metrics reporting method.')
parser.add_argument(
'--daemonize',
action='store_true',
help='Disengage from controlling terminal and become a daemon')
parser.add_argument(
'--process-user',
type=str,
help='If run as root, switch simulator daemon to this user right '
'upon binding privileged ports')
parser.add_argument(
'--process-group',
type=str,
help='If run as root, switch simulator daemon to this group right '
'upon binding privileged ports')
parser.add_argument('--pid-file',
metavar='<FILE>',
type=str,
default='/var/run/%s/%s.pid' % (__name__, os.getpid()),
help='SNMP simulation data file to write records to')
parser.add_argument(
'--cache-dir',
metavar='<DIR>',
type=str,
help='Location for SNMP simulation data file indices to create')
parser.add_argument(
'--force-index-rebuild',
action='store_true',
help='Rebuild simulation data files indices even if they seem '
'up to date')
parser.add_argument(
'--validate-data',
action='store_true',
help='Validate simulation data files on daemon start-up')
parser.add_argument('--variation-modules-dir',
metavar='<DIR>',
type=str,
action='append',
default=[],
help='Variation modules search path(s)')
parser.add_argument('--variation-module-options',
metavar='<module[=alias][:args]>',
type=str,
action='append',
default=[],
help='Options for a specific variation module')
parser.add_argument(
'--v2c-arch',
action='store_true',
help='Use lightweight, legacy SNMP architecture capable to support '
'v1/v2c versions of SNMP')
parser.add_argument(
'--v3-only',
action='store_true',
help='Trip legacy SNMP v1/v2c support to gain a little lesser memory '
'footprint')
parser.add_argument(
'--transport-id-offset',
type=int,
default=0,
help='Start numbering the last sub-OID of transport endpoint OIDs '
'starting from this ID')
parser.add_argument(
'--max-var-binds',
type=int,
default=64,
help='Maximum number of variable bindings to include in a single '
'response')
parser.add_argument('--data-dir',
type=str,
action='append',
metavar='<DIR>',
dest='data_dirs',
help='SNMP simulation data recordings directory.')
endpoint_group = parser.add_mutually_exclusive_group(required=True)
endpoint_group.add_argument(
'--agent-udpv4-endpoint',
type=str,
action='append',
metavar='<[X.X.X.X]:NNNNN>',
dest='agent_udpv4_endpoints',
default=[],
help='SNMP agent UDP/IPv4 address to listen on (name:port)')
endpoint_group.add_argument(
'--agent-udpv6-endpoint',
type=str,
action='append',
metavar='<[X:X:..X]:NNNNN>',
dest='agent_udpv6_endpoints',
default=[],
help='SNMP agent UDP/IPv6 address to listen on ([name]:port)')
args = parser.parse_args()
if args.cache_dir:
confdir.cache = args.cache_dir
if args.variation_modules_dir:
confdir.variation = args.variation_modules_dir
variation_modules_options = variation.parse_modules_options(
args.variation_module_options)
with daemon.PrivilegesOf(args.process_user, args.process_group):
proc_name = os.path.basename(sys.argv[0])
try:
log.set_logger(proc_name, *args.logging_method, force=True)
if args.log_level:
log.set_level(args.log_level)
except SnmpsimError as exc:
sys.stderr.write('%s\r\n' % exc)
parser.print_usage(sys.stderr)
return 1
try:
ReportingManager.configure(*args.reporting_method)
except SnmpsimError as exc:
sys.stderr.write('%s\r\n' % exc)
parser.print_usage(sys.stderr)
return 1
if args.daemonize:
try:
daemon.daemonize(args.pid_file)
except Exception as exc:
sys.stderr.write('ERROR: cant daemonize process: %s\r\n' % exc)
parser.print_usage(sys.stderr)
return 1
if not os.path.exists(confdir.cache):
try:
with daemon.PrivilegesOf(args.process_user, args.process_group):
os.makedirs(confdir.cache)
except OSError as exc:
log.error('failed to create cache directory "%s": '
'%s' % (confdir.cache, exc))
return 1
else:
log.info('Cache directory "%s" created' % confdir.cache)
variation_modules = variation.load_variation_modules(
confdir.variation, variation_modules_options)
with daemon.PrivilegesOf(args.process_user, args.process_group):
variation.initialize_variation_modules(variation_modules,
mode='variating')
def configure_managed_objects(data_dirs,
data_index_instrum_controller,
snmp_engine=None,
snmp_context=None):
"""Build pysnmp Managed Objects base from data files information"""
_mib_instrums = {}
_data_files = {}
for dataDir in data_dirs:
log.info('Scanning "%s" directory for %s data '
'files...' % (dataDir, ','.join([
' *%s%s' % (os.path.extsep, x.ext)
for x in variation.RECORD_TYPES.values()
])))
if not os.path.exists(dataDir):
log.info('Directory "%s" does not exist' % dataDir)
continue
log.msg.inc_ident()
for (full_path, text_parser,
community_name) in datafile.get_data_files(dataDir):
if community_name in _data_files:
log.error(
'ignoring duplicate Community/ContextName "%s" for data '
'file %s (%s already loaded)' %
(community_name, full_path,
_data_files[community_name]))
continue
elif full_path in _mib_instrums:
mib_instrum = _mib_instrums[full_path]
log.info('Configuring *shared* %s' % (mib_instrum, ))
else:
data_file = datafile.DataFile(full_path, text_parser,
variation_modules)
data_file.index_text(args.force_index_rebuild,
args.validate_data)
MibController = controller.MIB_CONTROLLERS[
data_file.layout]
mib_instrum = MibController(data_file)
_mib_instrums[full_path] = mib_instrum
_data_files[community_name] = full_path
log.info('Configuring %s' % (mib_instrum, ))
log.info('SNMPv1/2c community name: %s' % (community_name, ))
contexts[univ.OctetString(community_name)] = mib_instrum
data_index_instrum_controller.add_data_file(
full_path, community_name)
log.msg.dec_ident()
del _mib_instrums
del _data_files
def get_bulk_handler(req_var_binds, non_repeaters, max_repetitions,
read_next_vars):
"""Only v2c arch GETBULK handler"""
N = min(int(non_repeaters), len(req_var_binds))
M = int(max_repetitions)
R = max(len(req_var_binds) - N, 0)
if R:
M = min(M, int(args.max_var_binds / R))
if N:
rsp_var_binds = read_next_vars(req_var_binds[:N])
else:
rsp_var_binds = []
var_binds = req_var_binds[-R:]
while M and R:
rsp_var_binds.extend(read_next_vars(var_binds))
var_binds = rsp_var_binds[-R:]
M -= 1
return rsp_var_binds
def commandResponderCbFun(transport_dispatcher, transport_domain,
transport_address, whole_msg):
"""v2c arch command responder request handling callback"""
while whole_msg:
msg_ver = api.decodeMessageVersion(whole_msg)
if msg_ver in api.protoModules:
p_mod = api.protoModules[msg_ver]
else:
log.error('Unsupported SNMP version %s' % (msg_ver, ))
return
req_msg, whole_msg = decoder.decode(whole_msg,
asn1Spec=p_mod.Message())
community_name = req_msg.getComponentByPosition(1)
for candidate in datafile.probe_context(
transport_domain,
transport_address,
context_engine_id=datafile.SELF_LABEL,
context_name=community_name):
if candidate in contexts:
log.info(
'Using %s selected by candidate %s; transport ID %s, '
'source address %s, context engine ID <empty>, '
'community name '
'"%s"' % (contexts[candidate], candidate,
univ.ObjectIdentifier(transport_domain),
transport_address[0], community_name))
community_name = candidate
break
else:
log.error('No data file selected for transport ID %s, source '
'address %s, community name '
'"%s"' % (univ.ObjectIdentifier(transport_domain),
transport_address[0], community_name))
return whole_msg
rsp_msg = p_mod.apiMessage.getResponse(req_msg)
rsp_pdu = p_mod.apiMessage.getPDU(rsp_msg)
req_pdu = p_mod.apiMessage.getPDU(req_msg)
if req_pdu.isSameTypeWith(p_mod.GetRequestPDU()):
backend_fun = contexts[community_name].readVars
elif req_pdu.isSameTypeWith(p_mod.SetRequestPDU()):
backend_fun = contexts[community_name].writeVars
elif req_pdu.isSameTypeWith(p_mod.GetNextRequestPDU()):
backend_fun = contexts[community_name].readNextVars
elif (hasattr(p_mod, 'GetBulkRequestPDU')
and req_pdu.isSameTypeWith(p_mod.GetBulkRequestPDU())):
if not msg_ver:
log.info('GETBULK over SNMPv1 from %s:%s' %
(transport_domain, transport_address))
return whole_msg
def backend_fun(var_binds):
return get_bulk_handler(
var_binds, p_mod.apiBulkPDU.getNonRepeaters(req_pdu),
p_mod.apiBulkPDU.getMaxRepetitions(req_pdu),
contexts[community_name].readNextVars)
else:
log.error('Unsupported PDU type %s from '
'%s:%s' % (req_pdu.__class__.__name__,
transport_domain, transport_address))
return whole_msg
try:
var_binds = backend_fun(p_mod.apiPDU.getVarBinds(req_pdu))
except NoDataNotification:
return whole_msg
except Exception as exc:
log.error('Ignoring SNMP engine failure: %s' % exc)
return whole_msg
if not msg_ver:
for idx in range(len(var_binds)):
oid, val = var_binds[idx]
if val.tagSet in SNMP_2TO1_ERROR_MAP:
var_binds = p_mod.apiPDU.getVarBinds(req_pdu)
p_mod.apiPDU.setErrorStatus(
rsp_pdu, SNMP_2TO1_ERROR_MAP[val.tagSet])
p_mod.apiPDU.setErrorIndex(rsp_pdu, idx + 1)
break
p_mod.apiPDU.setVarBinds(rsp_pdu, var_binds)
transport_dispatcher.sendMessage(encoder.encode(rsp_msg),
transport_domain,
transport_address)
return whole_msg
# Configure access to data index
log.info('Maximum number of variable bindings in SNMP '
'response: %s' % args.max_var_binds)
data_index_instrum_controller = controller.DataIndexInstrumController()
contexts = {univ.OctetString('index'): data_index_instrum_controller}
with daemon.PrivilegesOf(args.process_user, args.process_group):
configure_managed_objects(args.data_dirs or confdir.data,
data_index_instrum_controller)
contexts['index'] = data_index_instrum_controller
# Configure socket server
transport_dispatcher = AsyncoreDispatcher()
transport_index = args.transport_id_offset
for agent_udpv4_endpoint in args.agent_udpv4_endpoints:
transport_domain = udp.domainName + (transport_index, )
transport_index += 1
agent_udpv4_endpoint = (
endpoints.IPv4TransportEndpoints().add(agent_udpv4_endpoint))
transport_dispatcher.registerTransport(transport_domain,
agent_udpv4_endpoint[0])
log.info('Listening at UDP/IPv4 endpoint %s, transport ID '
'%s' % (agent_udpv4_endpoint[1], '.'.join(
[str(handler) for handler in transport_domain])))
transport_index = args.transport_id_offset
for agent_udpv6_endpoint in args.agent_udpv6_endpoints:
transport_domain = udp6.domainName + (transport_index, )
transport_index += 1
agent_udpv6_endpoint = (
endpoints.IPv4TransportEndpoints().add(agent_udpv6_endpoint))
transport_dispatcher.registerTransport(transport_domain,
agent_udpv6_endpoint[0])
log.info('Listening at UDP/IPv6 endpoint %s, transport ID '
'%s' % (agent_udpv6_endpoint[1], '.'.join(
[str(handler) for handler in transport_domain])))
transport_dispatcher.registerRecvCbFun(commandResponderCbFun)
transport_dispatcher.jobStarted(1) # server job would never finish
with daemon.PrivilegesOf(args.process_user, args.process_group,
final=True):
try:
transport_dispatcher.runDispatcher()
except KeyboardInterrupt:
log.info('Shutting down process...')
finally:
if variation_modules:
log.info('Shutting down variation modules:')
for name, contexts in variation_modules.items():
body = contexts[0]
try:
body['shutdown'](options=body['args'],
mode='variation')
except Exception as exc:
log.error('Variation module "%s" shutdown FAILED: '
'%s' % (name, exc))
else:
log.info('Variation module "%s" shutdown OK' % name)
transport_dispatcher.closeDispatcher()
log.info('Process terminated')
return 0
# Build PDU
trapPDU = pMod.TrapPDU()
pMod.apiTrapPDU.setDefaults(trapPDU)
# Traps have quite different semantics across proto versions
if pMod == api.PROTOCOL_MODULES[api.SNMP_VERSION_1]:
pMod.apiTrapPDU.setEnterprise(trapPDU, (1, 3, 6, 1, 1, 2, 3, 4, 1))
pMod.apiTrapPDU.setGenericTrap(trapPDU, 'coldStart')
# Build message
trapMsg = pMod.Message()
pMod.apiMessage.setDefaults(trapMsg)
pMod.apiMessage.setCommunity(trapMsg, 'public')
pMod.apiMessage.setPDU(trapMsg, trapPDU)
transportDispatcher = AsyncoreDispatcher()
# UDP/IPv4
transportDispatcher.registerTransport(
udp.DOMAIN_NAME, udp.UdpSocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(trapMsg), udp.DOMAIN_NAME, ('demo.snmplabs.com', 162)
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.DOMAIN_NAME, udp6.Udp6SocketTransport().openClientMode()
)
# Incluir el resto de campos del trap que se consideren oportunos
varBinds = pMod.apiTrapPDU.getVarBinds(reqPDU)
else:
varBinds = pMod.apiPDU.getVarBinds(reqPDU)
# Incluir el contenido de las varBinds en el correo electronico
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(('::1', 162))
)
transportDispatcher.jobStarted(1)
# Generate request for next row
v2c.apiBulkPDU.setVarBinds(
reqPDU, [ (x, v2c.null) for x,y in varBindTable[-1] ]
)
v2c.apiBulkPDU.setRequestID(reqPDU, v2c.getNextRequestID())
transportDispatcher.sendMessage(
encoder.encode(reqMsg), transportDomain, transportAddress
)
global startedAt
if time() - startedAt > 3:
raise Exception('Request timed out')
startedAt = time()
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(reqMsg), udp.domainName, ('demo.snmplabs.com', 161)
)
transportDispatcher.jobStarted(1)
# Dispatcher will finish as job#1 counter reaches zero
transportDispatcher.runDispatcher()
print('Generic Trap: %s' %
(pMod.apiTrapPDU.getGenericTrap(reqPDU).prettyPrint()))
print('Specific Trap: %s' %
(pMod.apiTrapPDU.getSpecificTrap(reqPDU).prettyPrint()))
print('Uptime: %s' %
(pMod.apiTrapPDU.getTimeStamp(reqPDU).prettyPrint()))
varBinds = pMod.apiTrapPDU.getVarBindList(reqPDU)
else:
varBinds = pMod.apiPDU.getVarBindList(reqPDU)
print('Var-binds:')
for oid, val in varBinds:
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode((IPADDR, PORT)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
"""#
from pysnmp.entity import engine, config
from pysnmp.entity.rfc3413 import cmdrsp, context
from pysnmp.proto import rfc1902
from pysnmp.carrier.asyncore.dispatch import AsyncoreDispatcher
from pysnmp.carrier.asyncore.dgram import udp
# Configuration parameters for each of SNMP Engines
snmpEngineInfo = (
('0102030405060708', udp.domainName + (0,), ('127.0.0.1', 161)),
('0807060504030201', udp.domainName + (1,), ('127.0.0.2', 161))
)
# Instantiate the single transport dispatcher object
transportDispatcher = AsyncoreDispatcher()
# Setup a custom data routing function to select snmpEngine by transportDomain
transportDispatcher.registerRoutingCbFun(lambda td, t, d: td)
# Instantiate and configure SNMP Engines
for snmpEngineId, transportDomain, transportAddress in snmpEngineInfo:
# Create SNMP engine with specific engineID
snmpEngine = engine.SnmpEngine(rfc1902.OctetString(hexValue=snmpEngineId))
# Register SNMP Engine object with transport dispatcher. Request incoming
# data from specific transport endpoint to be funneled to this SNMP Engine.
snmpEngine.registerTransportDispatcher(transportDispatcher, transportDomain)
# Transport setup
# Match response to request
if pMod.apiPDU.getRequestID(reqPDU) == pMod.apiPDU.getRequestID(
rspPDU):
# Check for SNMP errors reported
errorStatus = pMod.apiPDU.getErrorStatus(rspPDU)
if errorStatus:
print(errorStatus.prettyPrint())
else:
print('INFORM message delivered, response var-binds follow')
for oid, val in pMod.apiPDU.getVarBinds(rspPDU):
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
transportDispatcher.jobFinished(1)
return wholeMsg
transportDispatcher = AsyncoreDispatcher()
transportDispatcher.registerRecvCbFun(cbRecvFun)
transportDispatcher.registerTimerCbFun(cbTimerFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openClientMode())
transportDispatcher.sendMessage(encoder.encode(trapMsg), udp.domainName,
('demo.snmplabs.com', 162))
transportDispatcher.jobStarted(1)
# UDP/IPv6
# transportDispatcher.registerTransport(
# udp6.domainName, udp6.Udp6SocketTransport().openClientMode()
def mock_cmdgen_get_cmd(self, authData, transportTarget, *varNames, **kwargs):
self.snmpEngine.transportDispatcher = AsyncoreDispatcher()
return None, None, None, None
class SNMPPDUHarness(threading.Thread):
def __init__(self, pdu, listen_address, listen_port, community="public"):
super(SNMPPDUHarness, self).__init__()
self.logger = logging.getLogger(__name__)
self.pdu = pdu
self.snmp_handler = SNMPPDUHandler(self.pdu, community=community)
self.listen_address = listen_address
self.listen_port = listen_port
self.transportDispatcher = AsyncoreDispatcher()
self._lock = threading.Lock()
self._stop_requested = False
def run(self):
with self._lock:
if self._stop_requested:
return
self.logger.info("Starting PDU '{}' on {}:{}".format(
self.pdu.name, self.listen_address, self.listen_port)
)
self.transportDispatcher.registerRecvCbFun(
self.snmp_handler.message_handler)
# UDP/IPv4
self.transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
(self.listen_address, self.listen_port))
)
self.transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
self.transportDispatcher.runDispatcher()
except Exception:
self.transportDispatcher.closeDispatcher()
def stop(self):
with self._lock:
self._stop_requested = True
try:
self.transportDispatcher.jobFinished(1)
except KeyError:
pass # The job is not started yet and will not start
