def _handleGetStatus(output, msg):
results = ResultGetStatus()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Status')
if results.filterActive:
xml.AddAttribute('filterActive', 'true')
else:
xml.AddAttribute('filterActive', 'false')
if results.packetThreadRunning:
xml.AddAttribute('threadRunning', 'true')
else:
xml.AddAttribute('threadRunning', 'false')
xml.AddAttribute('maxCaptureSize', '%u' % results.maxCaptureFileSize)
xml.AddAttribute('captureFile', results.captureFile)
xml.AddAttribute('captureFileSize', '%u' % results.captureFileSize)
xml.AddAttribute('maxPacketSize', '%u' % results.maxPacketSize)
if len(results.key) > 0:
sub = xml.AddSubElement('EncryptionKey')
sub.SetTextAsData(results.key)
sub = xml.AddSubElement('Version')
sub.AddAttribute('major', '%u' % results.majorVersion)
sub.AddAttribute('minor', '%u' % results.minorVersion)
sub.AddAttribute('revision', '%u' % results.revision)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.status.cmd.time',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Time', 'time', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Time')
result = Result()
result.Demarshal(msg)
xml.AddTimeElement('LocalTime', result.localTime)
xml.AddSubElementWithText('LocalTimeSeconds',
'%u' % result.localTime.GetSeconds())
xml.AddTimeElement('SystemTime', result.systemTime)
xml.AddSubElementWithText('SystemTimeSeconds',
'%u' % result.systemTime.GetSeconds())
sub = xml.AddSubElement('TimeZone')
sub.AddTimeElement('Bias', result.bias)
if result.state == RESULT_STATE_STANDARD:
sub.AddSubElementWithText('CurrentState', 'Standard')
elif result.state == RESULT_STATE_DAYLIGHT:
sub.AddSubElementWithText('CurrentState', 'Daylight')
else:
sub.AddSubElementWithText('CurrentState', 'Unknown')
sub = xml.AddSubElement('DaylightSavingsTime')
_writeDstInfo('Standard', result.standardBias, result.standardMonth,
result.standardWeek, result.standardDay, result.standardName,
sub)
_writeDstInfo('Daylight', result.daylightBias, result.daylightMonth,
result.daylightWeek, result.daylightDay, result.daylightName,
sub)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handlePersistence(namespace, output, msg):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('KiSuSurveyPersistence')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
result = ResultPersistence()
result.Demarshal(msg)
sub = xml.AddSubElement('Method')
if result.type == RESULT_PERSISTENCE_TYPE_LAUNCHER:
sub.AddSubElementWithText('Type', 'DRIVER')
elif result.type == RESULT_PERSISTENCE_TYPE_SOTI:
sub.AddSubElementWithText('Type', 'SOTI')
elif result.type == RESULT_PERSISTENCE_TYPE_JUVI:
sub.AddSubElementWithText('Type', 'JUVI')
else:
sub.AddSubElementWithText('Type', 'UNKNOWN')
if result.compatible:
sub.AddSubElementWithText('Compatible', 'true')
else:
sub.AddSubElementWithText('Compatible', 'false')
if result.reason != 0:
mcl.imports.ImportWithNamespace(namespace, 'mcf.kisu.diba_errors',
globals())
if mcf.kisu.diba_errors.errorStrings.has_key(result.reason):
reasonStr = mcf.kisu.diba_errors.errorStrings[result.reason]
else:
reasonStr = 'Unknown (0x%08x)' % result.reason
sub.AddSubElementWithText('Reason', reasonStr)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def _handleQueryData(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('QueryResponse')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
data = ResultQuery()
data.Demarshal(msg)
sub = xml.AddSubElement('Resource')
sub.AddSubElementWithText('Name', data.name)
if data.hasPath:
sub.AddSubElementWithText('Path', data.path)
type = sub.AddSubElement('Type')
if data.admin:
type.AddAttribute('admin', 'true')
else:
type.AddAttribute('admin', 'false')
if data.type == RESULT_QUERY_TYPE_DISK:
type.SetText('Disk')
elif data.type == RESULT_QUERY_TYPE_DEVICE:
type.SetText('Device')
elif data.type == RESULT_QUERY_TYPE_PRINT:
type.SetText('Print')
elif data.type == RESULT_QUERY_TYPE_IPC:
type.SetText('IPC')
else:
type.SetText('Unknown')
sub.AddSubElementWithText('Caption', data.caption)
sub.AddSubElementWithText('Description', data.description)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.gezu.cmd.GeZu_KernelMemory',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('GeZu_KernelMemory', 'GeZu_KernelMemory', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('GeZu_KernelMemoryResponse')
results = Result()
results.Demarshal(msg)
sub = xml.AddSubElement('MemDump')
sub.SetTextAsData(results.memDump)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleWindowStationData(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('WindowStations')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
submsg = msg.FindMessage(MSG_KEY_RESULT_WINDOW_STATION)
info = ResultWindowStations()
info.Demarshal(submsg)
sub = xml.AddSubElement('WindowStation')
sub.AddAttribute('name', info.name)
if info.openStatus != 0:
error = output.TranslateOsError(info.openStatus)
sub.AddAttribute('status', error)
else:
sub.AddAttribute('flags', '0x%08x' % info.flags)
if info.flags & RESULT_WINSTA_FLAG_VISIBLE:
sub.AddSubElement('WindowStationFlag_Visible')
while submsg.GetNumRetrieved() < submsg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
desktop = submsg.FindString(MSG_KEY_RESULT_WINDOW_STATION_DESKTOP)
sub.AddSubElementWithText('Desktop', desktop)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def _handleWindowsData(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Windows')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
info = ResultWindowInfo()
info.Demarshal(msg)
sub = xml.AddSubElement('Window')
sub.AddAttribute('hWnd', '0x%x' % info.hWnd)
sub.AddAttribute('hParent', '0x%x' % info.hParent)
sub.AddAttribute('pid', '%u' % info.owningPid)
sub.AddAttribute('title', info.text)
sub.AddAttribute('x', '%d' % info.x)
sub.AddAttribute('y', '%d' % info.y)
sub.AddAttribute('width', '%u' % info.width)
sub.AddAttribute('height', '%u' % info.height)
if info.flags & RESULT_WININFO_FLAG_IS_VISIBLE:
sub.AddSubElement('WindowIsVisible')
if info.flags & RESULT_WININFO_FLAG_IS_MINIMIZED:
sub.AddSubElement('WindowIsMinimized')
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def _handleList(namespace, output, msg):
import mcl.imports
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('KiSuEnumeration')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
result = ResultInstance()
result.Demarshal(msg)
if result.id != 0:
sub = xml.AddSubElement('KiSu')
sub.AddAttribute('id', '0x%08x' % result.id)
sub.AddAttribute('versionMajor', '%u' % result.versionMajor)
sub.AddAttribute('versionMinor', '%u' % result.versionMinor)
sub.AddAttribute('versionFix', '%u' % result.versionFix)
sub.AddAttribute('versionBuild', '%u' % result.versionBuild)
mcl.imports.ImportWithNamespace(namespace, 'mcf.kisu.ids',
globals())
for name in mcf.kisu.ids.nameTable:
if mcf.kisu.ids.nameTable[name] == result.id:
sub.AddAttribute('name', name)
break
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.status.cmd.objects', globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Objects', 'objects', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
else:
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Objects')
gotValidDir = False
objectList = list()
sub = None
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
result = Result()
try:
result.Demarshal(msg)
except:
output.RecordXml(xml)
raise
if result.flags & RESULT_FLAG_DIR_START:
_dumpObjects(sub, objectList)
_deleteObjects(objectList)
sub = xml.AddSubElement('ObjectDirectory')
sub.AddAttribute('name', result.name)
if result.status != 0:
errorStr = output.TranslateOsError(result.status)
sub.AddSubElementWithText('QueryFailure', errorStr)
else:
gotValidDir = True
elif sub != None:
_addObject(objectList, result)
_dumpObjects(sub, objectList)
_deleteObjects(objectList)
output.RecordXml(xml)
if gotValidDir:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
else:
output.EndWithStatus(mcl.target.CALL_FAILED)
return True
def _handleAuditQueryData(msg, output):
results = ResultAuditStatus()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Status')
if results.auditingEnabled:
xml.AddAttribute('current', 'ON')
else:
xml.AddAttribute('current', 'OFF')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
eventResults = ResultCategory()
eventResults.Demarshal(msg)
sub = xml.AddSubElement('Event')
if eventResults.flags & RESULT_FLAG_AUDIT_ONSUCCESS:
sub.AddSubElement('OnSuccess')
if eventResults.flags & RESULT_FLAG_AUDIT_ONFAILURE:
sub.AddSubElement('OnFailure')
category = _lookupName(eventResults.categoryGuid)
subcategory = _lookupName(eventResults.subcategoryGuid)
sub.AddAttribute(
'categoryGUID',
'%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x'
% (eventResults.categoryGuid[0], eventResults.categoryGuid[1],
eventResults.categoryGuid[2], eventResults.categoryGuid[3],
eventResults.categoryGuid[4], eventResults.categoryGuid[5],
eventResults.categoryGuid[6], eventResults.categoryGuid[7],
eventResults.categoryGuid[8], eventResults.categoryGuid[9],
eventResults.categoryGuid[10], eventResults.categoryGuid[11],
eventResults.categoryGuid[12], eventResults.categoryGuid[13],
eventResults.categoryGuid[14], eventResults.categoryGuid[15]))
sub.AddAttribute(
'subcategoryGUID',
'%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x'
%
(eventResults.subcategoryGuid[0], eventResults.subcategoryGuid[1],
eventResults.subcategoryGuid[2], eventResults.subcategoryGuid[3],
eventResults.subcategoryGuid[4], eventResults.subcategoryGuid[5],
eventResults.subcategoryGuid[6], eventResults.subcategoryGuid[7],
eventResults.subcategoryGuid[8], eventResults.subcategoryGuid[9],
eventResults.subcategoryGuid[10],
eventResults.subcategoryGuid[11],
eventResults.subcategoryGuid[12],
eventResults.subcategoryGuid[13],
eventResults.subcategoryGuid[14],
eventResults.subcategoryGuid[15]))
sub.AddAttribute('category', category)
sub.AddAttribute('categoryNative', eventResults.category)
if len(eventResults.subcategory) > 0:
sub.AddAttribute('subcategory', subcategory)
sub.AddAttribute('subcategoryNative', eventResults.subcategory)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def RecordModuleError(self,
moduleError,
osError,
modErrorStrings={},
translateOsError=True,
osErrorStrings=None,
translateMclStatusError=True):
import mcl.status
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Errors')
if modErrorStrings.has_key(moduleError):
modErrorStr = modErrorStrings[moduleError]
elif translateMclStatusError and mcl.status.errorStrings.has_key(
moduleError):
modErrorStr = mcl.status.errorStrings[moduleError]
else:
modErrorStr = '0x%08x' % moduleError
haveErrorData = False
if len(modErrorStr) > 0:
sub = xml.AddSubElement('ModuleError')
sub.AddAttribute('value', '%u' % moduleError)
sub.SetText(modErrorStr)
haveErrorData = True
if osError != 0:
try:
if translateOsError and osErrorStrings == None:
osErrorStr = self.TranslateOsError(osError)
elif translateOsError and osErrorStrings != None and osErrorStrings.has_key(
osError):
osErrorStr = osErrorStrings[osError]
else:
osErrorStr = 'Additional Error: %d (0x%x)' % (osError,
osError)
except:
osErrorStr = 'Unknown Error: %u (0x%x)' % (osError, osError)
sub = xml.AddSubElement('OsError')
sub.AddAttribute('value', '%u' % osError)
sub.SetText(osErrorStr)
haveErrorData = True
if haveErrorData == True:
self.RecordXml(xml)
return
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.network.cmd.banner',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Banner', 'banner', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
if moduleError == ERR_RECV_TIMEOUT:
output.SetTaskStatus(mcl.target.CALL_SUCCEEDED)
else:
output.SetTaskStatus(input.GetStatus())
output.End()
return True
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
result = Result()
result.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
if result.socketType == SOCKET_TYPE_TCP:
xml.Start('Connected')
output.RecordXml(xml)
xml.Start('Transfer')
xml.AddAttribute('address', '%s' % result.rspAddr)
xml.AddAttribute('port', '%u' % result.port)
sub = xml.AddSubElement('Data')
sub.AddAttribute('size', '%u' % len(result.response))
if len(result.response) > 0:
sub.SetTextAsData(result.response)
textStr = ''
for char in result.response:
if char == ord('\r') or char == ord('\n') or char == ord(
'\t') or char >= ord(' ') and char <= ord('~'):
textStr = textStr + chr(char)
else:
textStr = textStr + '?'
sub = xml.AddSubElementWithText('Text', textStr)
output.RecordXml(xml)
output.End()
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.status.cmd.memory',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Memory', 'memory', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
results = Result()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Memory')
physicalLoad = 100 - 100 * (float(results.physicalAvail) /
float(results.physicalTotal))
xml.AddAttribute('physicalLoad', '%u' % int(physicalLoad))
sub = xml.AddSubElement('Physical')
sub.AddAttribute('total', '%u' % results.physicalTotal)
sub.AddAttribute('available', '%u' % results.physicalAvail)
sub = xml.AddSubElement('Page')
sub.AddAttribute('total', '%u' % results.pageTotal)
sub.AddAttribute('available', '%u' % results.pageAvail)
if results.virtualTotal > 0:
sub = xml.AddSubElement('Virtual')
sub.AddAttribute('total', '%u' % results.virtualTotal)
sub.AddAttribute('available', '%u' % results.virtualAvail)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.file.cmd.grep',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Grep', 'grep', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
filemsg = msg.FindMessage(MSG_KEY_RESULT_FILE)
result = ResultFileInfo()
result.Demarshal(filemsg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('File')
xml.AddAttribute('location', result.file)
if result.openStatus != 0:
errStr = output.TranslateOsError(result.openStatus)
xml.AddAttribute('error', errStr)
else:
while filemsg.GetNumRetrieved() < filemsg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
line = ResultLine()
line.Demarshal(filemsg)
if len(line.line) > 0:
sub = xml.AddSubElement('Line')
sub.AddAttribute('position', '%u' % line.position)
sub.SetText(line.line)
output.RecordXml(xml)
output.End()
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.file.cmd.drives',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Drives', 'drives', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Drives')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
data = Result()
data.Demarshal(msg)
sub = xml.AddSubElement('Drive')
sub.AddSubElementWithText('Path', data.location)
sub.AddSubElementWithText('Type', _getDriveType(data.type))
if len(data.source) > 0:
sub.AddSubElementWithText('Source', data.source)
if len(data.filesystem) > 0:
sub.AddSubElementWithText('FileSystem', data.filesystem)
if len(data.options) > 0:
sub.AddSubElementWithText('Options', data.options)
if data.maxComponentLength > 0:
sub.AddSubElementWithText('MaximumComponentLength',
'%u' % data.maxComponentLength)
if data.volumeSerialNumber != 0:
sub.AddSubElementWithText(
'SerialNumber',
'%04x-%04x' % (data.volumeSerialNumber >> 16 & 65535,
data.volumeSerialNumber & 65535))
if data.flags != 0:
_addFlags(sub, data.flags)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.survey.cmd.registryhive',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.survey.cmd.registryhive.types',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('RegistryHive', 'registryhive', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('CommandAction')
hive = ResultHive()
hive.Demarshal(msg)
action = 'Unknown'
if hive.action == mca.survey.cmd.registryhive.types.ACTION_LOAD:
action = 'Load'
elif hive.action == mca.survey.cmd.registryhive.types.ACTION_UNLOAD:
action = 'Unload'
elif hive.action == mca.survey.cmd.registryhive.types.ACTION_SAVE:
action = 'Save'
xml.AddAttribute('action', action)
sub = xml.AddSubElement('Hive')
sub.AddAttribute('key', hive.key)
sub.AddAttribute('hive', _getHiveString(hive.hive))
sub.AddAttribute('file', hive.file)
if hive.permanent:
sub.AddAttribute('permanent', 'true')
else:
sub.AddAttribute('permanent', 'false')
output.RecordXml(xml)
if action == 'Load' and hive.permanent == False:
output.GoToBackground()
output.End()
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.network.cmd.arp',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Arp', 'arp', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
else:
if msg.GetCount() == 0:
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
initialResult = Result()
initialResult.Demarshal(msg)
moreData = initialResult.moreData
xml.Start('ArpEntries')
if initialResult.listType == RESULT_INITIAL_LIST:
xml.AddSubElement('ArpHeader')
_addArpEntry(xml, initialResult)
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
result = Result()
result.Demarshal(msg)
moreData = result.moreData
_addArpEntry(xml, result)
output.RecordXml(xml)
if moreData:
if initialResult.listType == RESULT_INITIAL_LIST:
output.GoToBackground()
output.End()
return True
output.SetTaskStatus(mcl.target.CALL_SUCCEEDED)
output.End()
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.process.cmd.processoptions',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('ProcessOptions', 'processoptions', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
if moduleError == ERR_ELEVATION_FAILED:
import mcl.elevation.errors
output.RecordModuleError(moduleError, 0, errorStrings)
output.RecordModuleError(osError, 0,
mcl.elevation.errors.errorStrings)
else:
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() > 0:
result = Result()
result.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ExecuteOptions')
xml.AddAttribute('processId', '%u' % result.processId)
xml.AddAttribute('value', '0x%08x' % result.value)
if result.value & EXECUTE_OPTION_EXECUTION_DISABLED:
xml.AddSubElement('ExecutionDisabled')
if result.value & EXECUTE_OPTION_EXECUTION_ENABLED:
xml.AddSubElement('ExecutionEnabled')
if result.value & EXECUTE_OPTION_DISABLE_THUNK_EMULATION:
xml.AddSubElement('DisableThunkEmulation')
if result.value & EXECUTE_OPTION_PERMANENT:
xml.AddSubElement('Permanent')
if result.value & EXECUTE_OPTION_EXECUTE_DISPATH_ENABLE:
xml.AddSubElement('ExecuteDispatchEnabled')
if result.value & EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE:
xml.AddSubElement('ImageDispatchEnabled')
if result.value & EXECUTE_OPTION_DISABLE_EXCEPTION_CHAIN_VALIDATION:
xml.AddSubElement('DisableExceptionChainValidation')
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.survey.cmd.systemversion',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('SystemVersion', 'systemversion', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
result = Result()
result.Demarshal(msg)
xml.Start('SystemVersion')
if mcl.os.archNames.has_key(result.arch):
xml.AddAttribute('architecture', mcl.os.archNames[result.arch])
else:
xml.AddAttribute('architecture', 'unknown')
xml.AddAttribute('architectureValue', '%u' % result.arch)
if mcl.os.osNames.has_key(result.os):
xml.AddAttribute('platform', mcl.os.osNames[result.os])
else:
xml.AddAttribute('platform', 'unknown')
xml.AddAttribute('platformValue', '%u' % result.os)
xml.AddAttribute('major', '%u' % result.majorVersion)
xml.AddAttribute('minor', '%u' % result.minorVersion)
xml.AddAttribute('revisionMajor', '%u' % result.revisionMajor)
xml.AddAttribute('revisionMinor', '%u' % result.revisionMinor)
xml.AddAttribute('build', '%u' % result.build)
xml.AddSubElementWithText('ExtraInfo', result.extraInfo)
if result.os == mcl.os.MCL_OS_WINNT or result.os == mcl.os.MCL_OS_WIN9X:
sub = xml.AddSubElement('Flags')
_addWindowsFlags(sub, result.flags)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.network.cmd.ping',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Ping', 'ping', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('PingResponse')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
results = Result()
results.Demarshal(msg)
sub = xml.AddSubElement('Response')
sub.AddTimeElement('Elapsed', results.time)
sub.AddAttribute('length', '%u' % len(results.rawData))
if results.ttl != 0:
sub.AddAttribute('ttl', '%u' % results.ttl)
dataSub = sub.AddSubElement('Data')
dataSub.SetTextAsData(results.rawData)
sub.AddAddressIP('FromAddr', results.fromAddr)
sub.AddAddressIP('ToAddr', results.toAddr)
if results.type == REPLY_TYPE_REPLY:
sub.AddAttribute('type', 'REPLY')
elif results.type == REPLY_TYPE_DEST_UNREACH:
sub.AddAttribute('type', 'DESTINATION_UNREACHABLE')
else:
sub.AddAttribute('type', 'UNKNOWN')
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.process.cmd.environment',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Environment', 'environment', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Environment')
setType = False
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
results = Result()
results.Demarshal(msg)
if not setType:
if results.action == ACTION_GET:
xml.AddAttribute('action', 'GET')
elif results.action == ACTION_SET:
xml.AddAttribute('action', 'SET')
elif results.action == ACTION_DELETE:
xml.AddAttribute('action', 'DELETE')
else:
xml.AddAttribute('action', 'UNKNOWN')
setType = True
sub = xml.AddSubElement('Value')
sub.AddAttribute('name', results.variable)
sub.SetText(results.value)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.file.cmd.delete',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Delete', 'delete', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Deletions')
encounteredErrors = False
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
result = Result()
result.Demarshal(msg)
if result.deleteStatus != 0:
encounteredErrors = True
sub = xml.AddSubElement('FileDelete')
sub.AddAttribute('file', result.filename)
sub.AddAttribute('statusValue', '0x%08x' % result.deleteStatus)
if result.afterReboot:
sub.AddAttribute('delay', 'true')
else:
sub.AddAttribute('delay', 'false')
sysError = output.TranslateOsError(result.deleteStatus)
sub.AddSubElementWithText('StatusString', sysError)
output.RecordXml(xml)
if encounteredErrors:
output.EndWithStatus(mcl.target.CALL_FAILED)
else:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleStatus(output, msg):
if msg.GetCount() == 0:
output.RecordError('No status values returned')
return mcl.target.CALL_FAILED
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('StatusInfo')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
status = ResultStatus()
status.Demarshal(msg)
sub = xml.AddSubElement('Status')
sub.AddAttribute('index', '%u' % status.index)
sub.AddSubElementWithText('BoundProcess', '%u' % status.boundProcess)
sub.AddTimeElement('LastTriggerTime', status.lastTriggerTime)
sub.AddSubElementWithText('Mailslot', status.commsPath)
sub2 = sub.AddSubElement('LastTriggerStatus')
sub2.AddAttribute('value', '%u' % status.lastTriggerStatus)
statusStr = 'UNKNOWN'
if status.lastTriggerStatus == RESULT_STATUS_TRIGGER_NONE:
statusStr = 'NONE'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_ACCEPTED:
statusStr = 'ACCEPTED'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_DECRYPT_FAILED:
statusStr = 'DECRYPT_FAILED'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_BAD_SIZE:
statusStr = 'BAD_SIZE'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_BAD_ID:
statusStr = 'BAD_ID'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_BAD_TIMESTAMP:
statusStr = 'BAD_TIMESTAMP'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_BAD_DST_ADDRESS:
statusStr = 'BAD_DST_ADDRESS'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_DELIVERY_FAILED:
statusStr = 'DELIVERY_FAILED'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_UNSUPPORTED_TYPE:
statusStr = 'UNSUPPORTED_TYPE'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_INVALID_AUTH:
statusStr = 'INVALID_AUTH'
elif status.lastTriggerStatus == RESULT_STATUS_TRIGGER_OTHER_FAILURE:
statusStr = 'OTHER_FAILURE'
else:
statusStr = 'OTHER_FAILURE'
sub2.SetText(statusStr)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.status.cmd.currentusers',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('CurrentUsers', 'currentusers', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('CurrentUsers')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
data = Result()
data.Demarshal(msg)
sub = xml.AddSubElement('User')
sub.AddAttribute('name', data.userName)
sub.AddAttribute('loginPid', '%u' % data.pid)
sub.AddAttribute('sessionId', '%u' % data.sessionId)
sub.AddAttribute('host', data.hostName)
sub.AddAttribute('device', data.devName)
if data.loginTime.GetTimeType(
) != data.loginTime.MCL_TIME_TYPE_INVALID:
sub.AddTimeElement('LoginTime', data.loginTime)
if data.idleTime.GetTimeType() != data.idleTime.MCL_TIME_TYPE_INVALID:
sub.AddTimeElement('IdleTime', data.idleTime)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleListData(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Shares')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
data = ResultList()
data.Demarshal(msg)
sub = xml.AddSubElement('Share')
sub.AddSubElementWithText('LocalName', data.local)
sub.AddSubElementWithText('RemoteName', data.remote)
sub.AddSubElementWithText('UserName', data.username)
sub.AddSubElementWithText('DomainName', data.domainName)
sub.AddSubElementWithText('Password', data.password)
sub.AddAttribute('referenceCount', '%u' % data.referenceCount)
sub.AddAttribute('useCount', '%u' % data.useCount)
if data.status == RESULT_LIST_STATUS_OK:
sub.AddSubElementWithText('Status', 'Ok')
elif data.status == RESULT_LIST_STATUS_PAUSED:
sub.AddSubElementWithText('Status', 'Paused')
elif data.status == RESULT_LIST_STATUS_DISCONNECTED:
sub.AddSubElementWithText('Status', 'Disconnected')
elif data.status == RESULT_LIST_STATUS_NETWORK_ERROR:
sub.AddSubElementWithText('Status', 'NetworkError')
elif data.status == RESULT_LIST_STATUS_CONNECTING:
sub.AddSubElementWithText('Status', 'Connecting')
elif data.status == RESULT_LIST_STATUS_RECONNECTING:
sub.AddSubElementWithText('Status', 'Reconnecting')
else:
sub.AddSubElementWithText('Status', 'Unknown')
if data.type == RESULT_LIST_TYPE_WILDCARD:
sub.AddSubElementWithText('Type', 'Wildcard')
elif data.type == RESULT_LIST_TYPE_DISK_DEVICE:
sub.AddSubElementWithText('Type', 'Disk Device')
elif data.type == RESULT_LIST_TYPE_SPOOL_DEVICE:
sub.AddSubElementWithText('Type', 'Spool Device')
elif data.type == RESULT_LIST_TYPE_IPC:
sub.AddSubElementWithText('Type', 'Interprocess Communication')
else:
sub.AddSubElementWithText('Type', 'Unknown')
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleSqlError(msg, output):
if msg.GetCount() == 0:
output.RecordError('No data returned')
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
results = ResultError()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Sql')
sub = xml.AddSubElement('Error')
sub.AddSubElementWithText('ErrorCode', '%d' % results.errorCode)
sub.AddSubElementWithText('SqlState', results.sqlState)
sub.AddSubElementWithText('Message', results.msg)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_FAILED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.status.cmd.devicequery',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('DeviceQuery', 'devicequery', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Devices')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
result = Result()
result.Demarshal(msg)
sub = xml.AddSubElement('Device')
sub.AddSubElementWithText('FriendlyName', result.friendlyName)
sub.AddSubElementWithText('DeviceDesc', result.deviceDesc)
sub.AddSubElementWithText('HardwareId', result.hardwareId)
sub.AddSubElementWithText('ServicePath', result.servicePath)
sub.AddSubElementWithText('Driver', result.driver)
sub.AddSubElementWithText('LocationInfo', result.location)
sub.AddSubElementWithText('Mfg', result.mfg)
sub.AddSubElementWithText('PhysDevObjName',
result.physicalDeviceObjectName)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleDuplicateTokenList(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ProcessList')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
item = ResultList()
item.Demarshal(msg)
sub = xml.AddSubElement('Process')
sub.AddAttribute('id', '%u' % item.id)
sub.AddAttribute('name', item.name)
sub.AddAttribute('user', item.user)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleButtonsData(msg, output):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Buttons')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
info = ResultButton()
info.Demarshal(msg)
sub = xml.AddSubElement('Button')
if info.flags & RESULT_BUTTON_FLAG_IS_ENABLED:
sub.AddAttribute('enabled', 'true')
else:
sub.AddAttribute('enabled', 'false')
sub.AddAttribute('id', '%u' % info.id)
sub.SetText(info.text)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.network.cmd.traceroute',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Traceroute', 'traceroute', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Hops')
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
results = Result()
results.Demarshal(msg)
sub = xml.AddSubElement('HopInfo')
sub.AddSubElementWithText('HopNumber', '%u' % results.hopNum)
sub.AddTimeElement('TripTime', results.tripTime)
sub.AddSubElementWithText('Host', results.host)
output.RecordXml(xml)
output.End()
return True