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.systempaths',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('SystemPaths', 'systempaths', [])
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('Dirs')
results = Result()
results.Demarshal(msg)
xml.AddSubElementWithText('WindowsDir', results.windowsPath)
xml.AddSubElementWithText('SystemDir', results.systemPath)
xml.AddSubElementWithText('TempDir', results.tempPath)
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.process.cmd.remoteexecute',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('RemoteExecute', 'remoteexecute', [])
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('RemoteProcess')
xml.AddSubElementWithText('Id', '%u' % results.processId)
xml.AddSubElementWithText('RetVal', '%d' % results.returnValue)
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.move',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Move', 'move', [])
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('Results')
if results.afterReboot:
xml.AddAttribute('delay', 'true')
else:
xml.AddAttribute('delay', 'false')
xml.AddSubElementWithText('Source', results.fullSrcPath)
xml.AddSubElementWithText('Destination', results.fullDstPath)
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.sidlookup',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('SidLookup', 'sidlookup', [])
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
result = Result()
result.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Sid')
xml.AddSubElementWithText('Id', result.id)
xml.AddSubElementWithText('Name', result.name)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def _handleVersion(output, msg):
version = ResultVersion()
version.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Version')
xml.AddSubElementWithText('Major', '%u' % version.major)
xml.AddSubElementWithText('Minor', '%u' % version.minor)
xml.AddSubElementWithText('Fix', '%u' % version.fix)
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.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 _handleMapData(msg, output):
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
results = ResultMap()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('MapResponse')
if len(results.resourceName) > 0:
xml.AddSubElementWithText('ResourceName', results.resourceName)
xml.AddSubElementWithText('ResourcePath', results.resourcePath)
output.RecordXml(xml)
output.GoToBackground()
output.End()
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.data.env
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.file.cmd.put',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Put', 'put', [])
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:
mcl.data.env.SetValue(LP_ENV_PUT_COMPLETE, 'true')
return True
results = Result()
try:
results.Demarshal(msg)
except:
output.RecordError('Failed to get callback parameters')
mcl.data.env.SetValue(LP_ENV_ERROR_ENCOUNTERED, 'true')
output.EndWithStatus(mcl.target.CALL_FAILED)
return True
if len(results.filePath) > 0:
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Results')
xml.AddSubElementWithText('File', results.filePath)
output.RecordXml(xml)
mcl.data.env.SetValue(LP_ENV_FILE_OPENED, 'true')
bytesLeft = int(mcl.data.env.GetValue(LP_ENV_BYTES_LEFT))
totalBytes = int(mcl.data.env.GetValue(LP_ENV_FILE_SIZE))
if results.bytesWritten > bytesLeft:
output.RecordError('Target reported more data written than is left?!')
mcl.data.env.SetValue(LP_ENV_ERROR_ENCOUNTERED, 'true')
output.EndWithStatus(mcl.target.CALL_FAILED)
return True
if results.bytesWritten > 0:
bytesLeft -= results.bytesWritten
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Results')
xml.AddAttribute('bytesWritten', '%u' % results.bytesWritten)
xml.AddAttribute('bytesLeft', '%u' % bytesLeft)
xml.AddAttribute('totalBytes', '%u' % totalBytes)
output.RecordXml(xml)
mcl.data.env.SetValue(LP_ENV_BYTES_LEFT, '%u' % bytesLeft)
output.End()
return True
def _handleStatus(output, msg):
results = StatusResult()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Status')
xml.AddSubElementWithText('Major', '%u' % results.major)
xml.AddSubElementWithText('Minor', '%u' % results.minor)
xml.AddSubElementWithText('Fix', '%u' % results.fix)
xml.AddSubElementWithText('Build', '%u' % results.build)
if results.available:
xml.AddSubElementWithText('Available', 'true')
else:
xml.AddSubElementWithText('Available', 'false')
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def _handleAdapters(output, msg):
if msg.GetCount() == 0:
output.RecordError('No status values returned')
return mcl.target.CALL_FAILED
submsg = msg.FindMessage(MSG_KEY_RESULT_ADAPTERS)
results = ResultFilterInfo()
results.Demarshal(submsg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('AdaptersInfo')
if results.threadRunning:
xml.AddAttribute('threadRunning', 'true')
else:
xml.AddAttribute('threadRunning', 'false')
if results.filterActive:
xml.AddAttribute('filterActive', 'true')
else:
xml.AddAttribute('filterActive', 'false')
xml.AddAttribute('numAdapters',
'%u' % submsg.GetCount(MSG_KEY_RESULT_ADAPTER_NAME))
while submsg.GetNumRetrieved() < submsg.GetCount():
if mcl.CheckForStop():
return mcl.target.CALL_FAILED
name = submsg.FindString(MSG_KEY_RESULT_ADAPTER_NAME)
xml.AddSubElementWithText('Adapter', name)
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.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.security.cmd.hide',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Hide', 'hide', [])
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_LIBRARY_CALL_FAILED:
import mcl.hiding.errors.process_hide
output.RecordModuleError(moduleError, 0, errorStrings)
output.RecordModuleError(
osError, 0, mcl.hiding.errors.process_hide.errorStrings)
elif moduleError == ERR_JUMPUP_FAILED:
output.RecordModuleError(moduleError, 0, errorStrings)
import mcl.privilege.errors
output.RecordModuleError(osError, 0,
mcl.privilege.errors.errorStrings)
else:
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
results = Result()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
if results.type == RESULT_TYPE_PROCESS_HIDE:
xml.Start('Hidden')
xml.AddAttribute('type', 'Process')
xml.AddAttribute('value', results.item)
elif results.type == RESULT_TYPE_PROCESS_UNHIDE:
xml.Start('Unhidden')
xml.AddAttribute('type', 'Process')
xml.AddAttribute('value', results.item)
else:
output.RecordError('Unhandled result type (%u)' % results.type)
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
if len(results.metaData) > 0:
xml.AddSubElementWithText('MetaData', results.metaData)
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.file.cmd.cd',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Cd', 'cd', [])
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
result = Result()
result.Demarshal(msg)
try:
import mcl.data.env
isVirtualDir = mcl.data.env.IsTrue('IsVirtual')
except:
isVirtualDir = False
xml = XmlOutput()
xml.Start('DirectoryInfo')
xml.AddSubElementWithText('CurrentDirectory', result.dir)
if isVirtualDir:
xml.AddAttribute('virtual', 'true')
else:
xml.AddAttribute('virtual', 'false')
output.RecordXml(xml)
if isVirtualDir:
import mcl.tasking.virtualdir
mcl.tasking.virtualdir.Set(result.dir)
output.EndWithStatus(input.GetStatus())
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.strings',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Strings', 'strings', [])
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('Strings')
file = msg.FindString(MSG_KEY_RESULT_FILE)
xml.AddSubElementWithText('File', file)
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
results = Result()
results.Demarshal(msg)
sub = xml.AddSubElement('String')
sub.SetText('%s' % results.value)
sub.AddAttribute('offset', '%u' % results.offset)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.env
import mcl.tasking.virtualdir
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.cd', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.cd.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['type'] == LP_CD_TYPE_REAL:
isVirtual = False
elif lpParams['type'] == LP_CD_TYPE_VIRTUAL:
isVirtual = True
else:
mcl.tasking.EchoError('Unhandled dir type (%u)' % lpParams['type'])
return False
try:
if isVirtual:
mcl.tasking.env.SetValue('IsVirtual', 'true')
else:
mcl.tasking.env.SetValue('IsVirtual', 'false')
except:
mcl.tasking.EchoError("Failed to set 'IsVirtual' environment variable")
return False
if lpParams['dir'] == None:
dir = ''
else:
dir = lpParams['dir']
if isVirtual:
if len(dir) > 0 and lpParams['force']:
try:
mcl.tasking.virtualdir.Set(dir)
except:
mcl.tasking.EchoError(
'Failed to set virtual working directory')
return False
try:
currentDir = mcl.tasking.virtualdir.GetFullPath(dir)
except:
mcl.tasking.EchoError('Failed to get virtual working directory')
return False
if len(currentDir) > 0:
if len(dir) == 0 or lpParams['force']:
if currentDir.startswith('\\\\?\\UNC\\'):
userDir = '\\\\%s' % currentDir[8:]
elif currentDir.startswith('\\\\?\\'):
userDir = currentDir[4:]
else:
userDir = currentDir
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('DirectoryInfo')
xml.AddSubElementWithText('CurrentDirectory', userDir)
xml.AddAttribute('virtual', 'true')
mcl.tasking.OutputXml(xml)
mcl.tasking.TaskSetStatus(mcl.target.CALL_SUCCEEDED)
return True
dir = currentDir
tgtParams = mca.file.cmd.cd.Params()
tgtParams.dir = dir
if isVirtual or len(tgtParams.dir) == 0:
rpc = mca.file.cmd.cd.tasking.RPC_INFO_QUERY
else:
rpc = mca.file.cmd.cd.tasking.RPC_INFO_SET
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.file.cmd.cd.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.env
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.scre.cmd.sql', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.scre.cmd.sql.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('CommandInfo')
xml.AddSubElementWithText('Action', actionMap[lpParams['actionCmd']])
if lpParams['actionCmd'] == _CMD_ACTION_LIST_DRIVERS:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_DRIVERS
elif lpParams['actionCmd'] == _CMD_ACTION_LIST_SOURCES:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_DATASOURCES
elif lpParams['actionCmd'] == _CMD_ACTION_LIST_HANDLES:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_HANDLES
else:
connectParams = mca.scre.cmd.sql.ParamsConnect()
connectParams.connectionString = lpParams['connectString']
if connectParams.connectionString == None:
if not mcl.tasking.env.CheckValue(
'_SCRE_HANDLE_CONNECT_STR_%u' % lpParams['handleId'],
globalValue=True) or not mcl.tasking.env.CheckValue(
'_SCRE_HANDLE_ACCESS_TYPE_%u' % lpParams['handleId'],
globalValue=True) or not mcl.tasking.env.CheckValue(
'_SCRE_HANDLE_AUTO_COMMIT_%u' %
lpParams['handleId'],
globalValue=True):
mcl.tasking.OutputError('The given handle id was not found')
return False
connectParams.connectionString = mcl.tasking.env.GetValue(
'_SCRE_HANDLE_CONNECT_STR_%u' % lpParams['handleId'],
globalValue=True)
accessType = mcl.tasking.env.GetValue(
'_SCRE_HANDLE_ACCESS_TYPE_%u' % lpParams['handleId'],
globalValue=True)
if accessType == 'READ ONLY':
connectParams.accessType = mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_ONLY
elif accessType == 'READ/WRITE':
connectParams.accessType = mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_WRITE
else:
mcl.tasking.OutputError('Unknown access type for handle %u' %
lpParams['handleId'])
return False
if not mcl.tasking.env.IsTrue(
'_SCRE_HANDLE_AUTO_COMMIT_%u' % lpParams['handleId'],
globalValue=True):
connectParams.flags &= ~mca.scre.cmd.sql.PARAMS_CONNECT_FLAG_AUTOCOMMIT
else:
if lpParams['accessType'] == _CMD_ACCESS_TYPE_READ:
connectParams.accessType = mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_ONLY
elif lpParams['accessType'] == _CMD_ACCESS_TYPE_READWRITE:
connectParams.accessType = mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_WRITE
else:
mcl.tasking.OutputError('Unknown access type')
return False
if not lpParams['autoCommit']:
connectParams.flags &= ~mca.scre.cmd.sql.PARAMS_CONNECT_FLAG_AUTOCOMMIT
if connectParams.connectionString == None or len(
connectParams.connectionString) == 0:
mcl.tasking.OutputError(
'A connection string must be specified')
return False
xml.AddSubElementWithText('ConnectionString',
connectParams.connectionString)
if not lpParams['allowConnect']:
connectParams.flags |= mca.scre.cmd.sql.PARAMS_CONNECT_FLAG_USE_EXISTING
if connectParams.accessType == mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_ONLY:
xml.AddSubElementWithText('AccessType', 'READ ONLY')
elif connectParams.accessType == mca.scre.cmd.sql.SQL_ACCESS_TYPE_READ_WRITE:
xml.AddSubElementWithText('AccessType', 'READ/WRITE')
else:
mcl.tasking.OutputError('Unknown access type')
return False
if connectParams.flags & mca.scre.cmd.sql.PARAMS_CONNECT_FLAG_AUTOCOMMIT:
xml.AddSubElementWithText('AutoCommit', 'true')
else:
xml.AddSubElementWithText('AutoCommit', 'false')
if mcl.tasking.env.CheckValue('_SCRE_TIMEOUT_SECONDS_%u' %
lpParams['handleId'],
globalValue=True):
connectParams.timeoutSeconds = int(
mcl.tasking.env.GetValue('_SCRE_TIMEOUT_SECONDS_%u' %
lpParams['handleId'],
globalValue=True))
else:
connectParams.timeoutSeconds = lpParams['timeout'].GetSeconds()
msg = MarshalMessage()
if lpParams['actionCmd'] == _CMD_ACTION_CONNECT:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_CONNECT
connectParams.Marshal(msg)
elif lpParams['actionCmd'] == _CMD_ACTION_LIST_SERVERS:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_SERVERS
connectParams.Marshal(msg)
else:
if lpParams['actionCmd'] == _CMD_ACTION_DISCONNECT:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_DISCONNECT
connectParams.Marshal(msg)
else:
queryParams = mca.scre.cmd.sql.ParamsQueryBase()
queryParams.connectInfo = connectParams
queryParams.maxColumnSize = lpParams['maxColumnSize']
queryParams.chunkSize = lpParams['chunkSize']
if queryParams.maxColumnSize < 1:
mcl.tasking.OutputError(
'maxColumnSize must be a positive number')
return False
xml.AddSubElementWithText('MaxColumnSize',
'%u' % queryParams.maxColumnSize)
if lpParams['actionCmd'] == _CMD_ACTION_LIST_DATABASES:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_DATABASES
queryParams.Marshal(msg)
elif lpParams['actionCmd'] == _CMD_ACTION_LIST_TABLES:
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_TABLES
queryParams.Marshal(msg)
elif lpParams['actionCmd'] == _CMD_ACTION_LIST_COLUMNS:
if lpParams['tableName'] == None or len(
lpParams['tableName']) == 0:
mcl.tasking.OutputError(
'A table name must be specified')
return False
tgtParams = mca.scre.cmd.sql.ParamsQueryColumns()
tgtParams.baseInfo = queryParams
tgtParams.tableName = lpParams['tableName']
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_LIST_COLUMNS
xml.AddSubElementWithText('TableName', tgtParams.tableName)
tgtParams.Marshal(msg)
elif lpParams['actionCmd'] == _CMD_ACTION_EXEC_QUERY:
if lpParams['queryString'] == None and lpParams[
'queryFile'] == None:
mcl.tasking.OutputError(
'A query string or file must be specified')
return False
tgtParams = mca.scre.cmd.sql.ParamsQueryStatement()
tgtParams.baseInfo = queryParams
if lpParams['queryString'] != None:
if len(lpParams['queryString']) == 0:
mcl.tasking.OutputError(
'Query string must have a value specified')
return False
tgtParams.queryString = lpParams['queryString']
xml.AddSubElementWithText('QueryString',
tgtParams.queryString)
else:
import mcl.tasking.resource
if len(lpParams['queryFile']) == 0:
mcl.tasking.OutputError(
'File must have a value specified')
return False
resFlags = 0
f, openedName, usedProject = mcl.tasking.resource.Open(
lpParams['queryFile'], resFlags, None, None)
if f == None:
mcl.tasking.OutputError(
"Failed to open local file '%s'" %
lpParams['queryFile'])
return False
try:
import os.path
import array
fileSize = os.path.getsize(openedName)
if fileSize == 0 or fileSize > 4294967295L:
mcl.tasking.OutputError(
"Invalid file size (%u) for put of '%s'" %
(fileSize, openedName))
return False
fileQueryString = f.read()
try:
unicode(fileQueryString, 'utf-8')
except:
mcl.tasking.OutputError(
'Input file could not be parsed as utf-8')
return False
finally:
f.close()
f = None
tgtParams.queryString = fileQueryString.strip()
xml.AddSubElementWithText('File',
lpParams['queryFile'])
xml.AddSubElementWithText('QueryString',
tgtParams.queryString)
rpc = mca.scre.cmd.sql.tasking.RPC_INFO_EXEC
tgtParams.Marshal(msg)
else:
mcl.tasking.OutputError('Unhandled action type (%u)' %
lpParams['actionCmd'])
return False
rpc.SetData(msg.Serialize())
xml.AddSubElementWithText('ConsoleOutput', 'true')
mcl.tasking.OutputXml(xml)
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.scre.cmd.sql.errorStrings)
return False
else:
return True
def _handleQuery(ACE_FLAGS, ACE_MASKS, msg, output):
qmsg = msg.FindMessage(MSG_KEY_RESULT_QUERY)
owner = ResultQueryInfo()
owner.Demarshal(qmsg)
queryType = 'Unknown'
if owner.type == TYPE_FILE:
queryType = 'File'
elif owner.type == TYPE_REG_KEY:
queryType = 'RegKey'
elif owner.type == TYPE_GENERIC:
if owner.objectType == 0:
queryType = 'SE_UNKNOWN_OBJECT_TYPE'
elif owner.objectType == 1:
queryType = 'SE_FILE_OBJECT'
elif owner.objectType == 2:
queryType = 'SE_SERVICE'
elif owner.objectType == 3:
queryType = 'SE_PRINTER'
elif owner.objectType == 4:
queryType = 'SE_REGISTRY_KEY'
elif owner.objectType == 5:
queryType = 'SE_LMSHARE'
elif owner.objectType == 6:
queryType = 'SE_KERNEL_OBJECT'
elif owner.objectType == 7:
queryType = 'SE_WINDOW_OBJECT'
elif owner.objectType == 8:
queryType = 'SE_DS_OBJECT'
elif owner.objectType == 9:
queryType = 'SE_DS_OBJECT_ALL'
elif owner.objectType == 10:
queryType = 'SE_PROVIDER_DEFINED_OBJECT'
elif owner.objectType == 11:
queryType = 'SE_WMIGUID_OBJECT'
elif owner.objectType == 12:
queryType = 'SE_REGISTRY_WOW64_32KEY'
else:
queryType = 'UNKNOWN'
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ObjectPerms')
xml.AddAttribute('type', queryType)
xml.AddAttribute('name', owner.object)
xml.AddAttribute('accountName', owner.account)
xml.AddAttribute('accountDomainName', owner.acctDomain)
xml.AddAttribute('groupName', owner.group)
xml.AddAttribute('groupDomainName', owner.groupDomain)
xml.AddSubElementWithText('PermissionString', owner.permString)
sub = xml.AddSubElement('Flags')
if owner.flags != 0:
if owner.flags & RESULT_SD_FLAG_DACL_AUTO_INHERIT_REQ:
sub.AddSubElement('SE_DACL_AUTO_INHERIT_REQ')
if owner.flags & RESULT_SD_FLAG_DACL_AUTO_INHERITED:
sub.AddSubElement('SE_DACL_AUTO_INHERITED')
if owner.flags & RESULT_SD_FLAG_DACL_DEFAULTED:
sub.AddSubElement('SE_DACL_DEFAULTED')
if owner.flags & RESULT_SD_FLAG_DACL_PRESENT:
sub.AddSubElement('SE_DACL_PRESENT')
if owner.flags & RESULT_SD_FLAG_DACL_PROTECTED:
sub.AddSubElement('SE_DACL_PROTECTED')
if owner.flags & RESULT_SD_FLAG_GROUP_DEFAULTED:
sub.AddSubElement('SE_GROUP_DEFAULTED')
if owner.flags & RESULT_SD_FLAG_OWNER_DEFAULTED:
sub.AddSubElement('SE_OWNER_DEFAULTED')
if owner.flags & RESULT_SD_FLAG_RM_CONTROL_VALID:
sub.AddSubElement('SE_RM_CONTROL_VALID')
if owner.flags & RESULT_SD_FLAG_SACL_AUTO_INHERIT_REQ:
sub.AddSubElement('SE_SACL_AUTO_INHERIT_REQ')
if owner.flags & RESULT_SD_FLAG_SACL_AUTO_INHERITED:
sub.AddSubElement('SE_SACL_AUTO_INHERITED')
if owner.flags & RESULT_SD_FLAG_SACL_DEFAULTED:
sub.AddSubElement('SE_SACL_DEFAULTED')
if owner.flags & RESULT_SD_FLAG_SACL_PRESENT:
sub.AddSubElement('SE_SACL_PRESENT')
if owner.flags & RESULT_SD_FLAG_SACL_PROTECTED:
sub.AddSubElement('SE_SACL_PROTECTED')
if owner.flags & RESULT_SD_FLAG_SELF_RELATIVE:
sub.AddSubElement('SE_SELF_RELATIVE')
while qmsg.GetNumRetrieved() < qmsg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
ace = ResultAce()
ace.Demarshal(qmsg)
sub = xml.AddSubElement('Acl')
if ace.aceType == RESULT_DACL_ACE:
sub.AddAttribute('type', 'DACL')
else:
sub.AddAttribute('type', 'SACL')
sub2 = sub.AddSubElement('Ace')
sub2.AddAttribute('typeValue', '%u' % ace.type)
sub2.AddAttribute('type', _getAceType(ace.type))
sub2.AddAttribute('user', ace.user)
sub2.AddAttribute('domain', ace.domain)
_addAceFlags(ACE_FLAGS, sub2, ace.flags)
_addAceAccessMask(ACE_MASKS, sub2, ace.accessMask)
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.domaincontroller',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('DomainController', 'domaincontroller', [])
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
rtn = mcl.target.CALL_SUCCEEDED
while msg.GetNumRetrieved() < msg.GetCount():
if mcl.CheckForStop():
output.EndWithStatus(mcl.target.CALL_FAILED)
return False
statusResults = ResultStatus()
statusResults.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('DomainController')
xml.AddSubElementWithText('DCName', statusResults.dc)
properties = xml.AddSubElement('Properties')
if statusResults.typeServ & RESULT_FLAG_TYPE_DOMAIN_CTRL:
properties.AddSubElement('Primary')
if statusResults.typeServ & RESULT_FLAG_TYPE_DOMAIN_BAKCTRL:
properties.AddSubElement('Backup')
if statusResults.extraInfoRtn != 0:
sub = xml.AddSubElement('ExtendedErrorInfo')
errorStr = output.TranslateOsError(statusResults.extraInfoRtn)
sub.AddSubElementWithText('QueryError', errorStr)
else:
results = ResultDomainController()
results.Demarshal(msg)
xml.AddSubElementWithText('DCFullName', results.dcName)
sub = xml.AddSubElement('DCAddress')
sub.SetText(results.dcAddress)
if results.addressType == RESULT_ADDRTYPE_INET:
sub.AddAttribute('addrType', 'IPAddress')
elif results.addressType == RESULT_ADDRTYPE_NETBIOS:
sub.AddAttribute('addrType', 'NetBIOS')
else:
sub.AddAttribute('addrType', 'Unknown')
xml.AddSubElementWithText('DomainGuid', results.domainGuid)
xml.AddSubElementWithText('DomainName', results.domainName)
xml.AddSubElementWithText('DnsForestName', results.dnsForestName)
xml.AddSubElementWithText('DCSiteName', results.dcSiteName)
xml.AddSubElementWithText('ClientSiteName', results.clientSiteName)
if results.flags & RESULT_FLAG_DC_KDC:
properties.AddSubElement('KerberosKeyDistCenter')
if results.flags & RESULT_FLAG_DC_GC:
properties.AddSubElement('GlobalCatalog')
if results.flags & RESULT_FLAG_DC_DS:
properties.AddSubElement('DirectoryService')
if results.flags & RESULT_FLAG_DC_TIMESERV:
properties.AddSubElement('TimeService')
if results.flags & RESULT_FLAG_DC_WRITABLE:
properties.AddSubElement('SAM')
if statusResults.dcEnumStatus == 1:
sub = xml.AddSubElement('AddlInformation')
sub.AddSubElementWithText(
'EnumQueryError',
'Although all domain controllers (dcs) were requested, only primary dc obtained as enumeration of dcs failed'
)
rtn = mcl.target.CALL_FAILED
output.RecordXml(xml)
output.EndWithStatus(rtn)
return True
