def DatabaseEnvParams(processId):
# This is imported here to avoid circular references.
from sources_types import CIM_Process
DEBUG("\nDatabaseEnvParams processId=%s", str(processId))
# Get the list of files open by the process.
try:
proc_obj = CIM_Process.PsutilGetProcObj(int(processId))
fillist = CIM_Process.PsutilProcOpenFiles(proc_obj)
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught:" + str(exc) + ": processId=" +
str(processId))
listArgs = []
for filObj in fillist:
filNam = filObj.path
DEBUG("DatabaseEnvParams processId=%s filNam=%s", str(processId),
filNam)
if IsSqliteDatabase(filNam):
DEBUG("DatabaseEnvParams ADDING filNam=%s", filNam)
filNamClean = lib_util.standardized_file_path(filNam)
filDef = {"File": filNamClean}
listArgs.append(filDef)
DEBUG("DatabaseEnvParams len=%d\n", len(listArgs))
return ("sqlite/query", listArgs)
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(pid)
node_process = lib_uris.gUriGen.PidUri(pid)
try:
all_maps = proc_obj.memory_maps()
except Exception as exc:
lib_common.ErrorMessageHtml("get_memory_maps Pid=%d. Caught %s\n" % (pid, str(exc)))
propMemoryRSS = lib_common.MakeProp("Resident Set Size")
for map_obj in all_maps:
# This, because all Windows paths are "standardized" by us.
# TODO: clean_map_path = lib_util.standardized_file_path(map_obj.path)
clean_map_path = map_obj.path.replace("\\", "/")
uri_mem_map = lib_uris.gUriGen.MemMapUri(clean_map_path)
grph.add((uri_mem_map, propMemoryRSS, rdflib.Literal(map_obj.rss)))
grph.add((node_process, pc.property_memmap, uri_mem_map))
cgiEnv.OutCgiRdf( "LAYOUT_SPLINE")
def Usable(entity_type, entity_ids_arr):
"""MS-Dos Batch processes"""
isWindows = lib_util.UsableWindows(entity_type, entity_ids_arr)
if not isWindows:
return False
pidProc = entity_ids_arr[0]
try:
# Any error, no display.
proc_obj = CIM_Process.PsutilGetProcObj(int(pidProc))
except:
return False
# The command line can be something like:
# C:\windows\system32\cmd.exe /c ""C:\Users\rchateau\Developpement\ReverseEngineeringApps\StartCgiServer.cmd" "
# "cmd.exe" /s /k pushd "C:\Users\rchateau\Developpement\ReverseEngineeringApps\PythonStyle\Tests"
# cmd /help
# "C:\windows\system32\cmd.exe"
#
# cmd_line = CIM_Process.PsutilProcToCmdline(proc_obj)
# cmdlinSplit = cmd_line.split(" ")
# execNam = cmdlinSplit[0]
# For all of these command lines, the path is always: "C:\Windows\System32\cmd.exe"
procName = CIM_Process.PsutilProcToName(proc_obj)
return procName == "cmd.exe"
def Main():
cgiEnv = lib_common.CgiEnv()
pid = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(pid)
nodeProcess = lib_common.gUriGen.PidUri(pid)
try:
all_maps = CIM_Process.PsutilProcMemmaps(proc_obj)
except:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("get_memory_maps Pid=%d. Caught %s\n" %
(pid, str(exc)))
propMemoryRSS = lib_common.MakeProp("Resident Set Size")
for map in all_maps:
# This, because all Windows paths are "standardized" by us.
cleanMapPath = map.path.replace("\\", "/")
uriMemMap = lib_common.gUriGen.MemMapUri(cleanMapPath)
grph.add((uriMemMap, propMemoryRSS, lib_common.NodeLiteral(map.rss)))
grph.add((nodeProcess, pc.property_memmap, uriMemMap))
cgiEnv.OutCgiRdf("LAYOUT_SPLINE")
def Main():
cgiEnv = lib_common.CgiEnv()
try:
top_pid = int( cgiEnv.GetId() )
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(top_pid)
node_process = lib_common.gUriGen.PidUri(top_pid)
CIM_Process.AddInfo( grph, node_process, [ str(top_pid) ] )
proc_cwd,proc_msg = CIM_Process.PsutilProcCwd(proc_obj)
if proc_cwd:
# proc_cwd = proc_cwd.replace("\\","/") # "Our" normalisation.
node_cwd = lib_common.gUriGen.FileUri( proc_cwd )
grph.add( ( node_process, pc.property_cwd, node_cwd ) )
else:
# The PID is added to the message such as "Access denied", so it is specific to the process
# and prevents nodes with the same text to be merged in RDF or when displayed in Javascript.
msgSpecific = "%s:Pid=%d" % (proc_msg,top_pid)
grph.add( ( node_process, pc.property_information, lib_common.NodeLiteral(msgSpecific)) )
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.CgiEnv()
grph = cgiEnv.GetGraph()
try:
procid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
objProc = CIM_Process.PsutilGetProcObj(procid)
envProp = lib_common.MakeProp("environment")
try:
# Psutil version after 4.0.0
envsDict = objProc.environ()
except:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Error:" + str(exc))
node_process = lib_common.gUriGen.PidUri(procid)
for envKey in envsDict:
envVal = envsDict[envKey]
DEBUG("envKey=%s envVal=%s", envKey, envVal)
nodeEnvNam = lib_util.NodeLiteral(envKey)
# When a file or a directory displayed with a node,
# its name is shortened so it can fit into the table.,
# so it is less visible.
# Some are probably for Windows only.
if envKey in ["PATH", "PSMODULEPATH", "PYPATH"]:
valSplit = envVal.split(os.pathsep)
nodFilArr = [
lib_common.gUriGen.DirectoryUri(filNam) for filNam in valSplit
]
nodFilArrNod = lib_util.NodeLiteral(nodFilArr)
#for filNam in valSplit:
# nodFil = lib_common.gUriGen.DirectoryUri(filNam)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFilArrNod))
elif os.path.isdir(envVal):
nodFil = lib_common.gUriGen.DirectoryUri(envVal)
#grph.add((nodeEnvNam,pc.property_directory,nodFil))
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFil))
elif os.path.exists(envVal):
nodFil = lib_common.gUriGen.FileUri(envVal)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFil))
#grph.add((nodeEnvNam,pc.property_directory,nodFil))
else:
# TODO: Beware that "\L" is transformed into "<TABLE>" by Graphviz !!!
envValClean = envVal.replace(">", "_").replace("<", "_").replace(
"&", "_").replace("\\", "_")
nodeEnvValue = lib_util.NodeLiteral(envValClean)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodeEnvValue))
grph.add((node_process, envProp, nodeEnvNam))
# cgiEnv.OutCgiRdf("LAYOUT_RECT", [pc.property_directory,envProp])
cgiEnv.OutCgiRdf("LAYOUT_RECT", [envProp])
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(pid)
#[pconn(fd=115, family=2, type=1, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED'),
# pconn(fd=117, family=2, type=1, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING'),
# pconn(fd=119, family=2, type=1, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED'),
node_process = lib_uris.gUriGen.PidUri(pid)
try:
connects = CIM_Process.PsutilProcConnections(proc_obj, 'all')
except Exception:
# Version 3.2.2 at least.
try:
connects = proc_obj.connections('all')
except Exception as exc:
lib_common.ErrorMessageHtml("Error:" + str(exc))
survol_addr.PsutilAddSocketToGraph(node_process, connects, grph)
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.CgiEnv()
try:
thePid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(thePid)
node_process = lib_common.gUriGen.PidUri(thePid)
CIM_Process.AddInfo(grph, node_process, [str(thePid)])
filCGroups = "/proc/%d/cgroup" % thePid
for lin_cg in open(filCGroups):
split_cg = lin_cg.split(':')
hierarchy = split_cg[0]
subsys_name_list = split_cg[1]
mount_path = split_cg[2]
mount_path_node = lib_common.gUriGen.DirectoryUri(mount_path)
for subsys_name in subsys_name_list.split(","):
cgrpNode = survol_cgroup.MakeUri(subsys_name)
grph.add((node_process, lib_common.MakeProp("CGroup"), cgrpNode))
grph.add((cgrpNode, lib_common.MakeProp("Hierarchy"),
lib_common.NodeLiteral(hierarchy)))
grph.add((cgrpNode, lib_common.MakeProp("Control group path"),
mount_path_node))
cgiEnv.OutCgiRdf()
def Usable(entity_type, entity_ids_arr):
"""Only for Java processes"""
pid_proc = entity_ids_arr[0]
proc_obj = CIM_Process.PsutilGetProcObj(int(pid_proc))
argv_array = CIM_Process.PsutilProcToCmdlineArray(proc_obj)
return "java" in argv_array[0]
def GetMemMaps(pidint):
# TODO: Replace this by scanning /proc/<pid>/mmaps
p = CIM_Process.PsutilGetProcObj(pidint)
# Depending on psutil version.
try:
return p.get_memory_maps(grouped=False)
except AttributeError:
# New version.
return p.memory_maps(grouped=False)
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
try:
procid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
obj_proc = CIM_Process.PsutilGetProcObj(procid)
env_prop = lib_common.MakeProp("environment")
try:
envs_dict = obj_proc.environ()
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:%s" % exc)
node_process = lib_uris.gUriGen.PidUri(procid)
for env_key in envs_dict :
env_val = envs_dict[env_key]
logging.debug("env_key=%s env_val=%s", env_key, env_val)
node_env_nam = lib_util.NodeLiteral(env_key)
# When a file or a directory displayed with a node,
# its name is shortened so it can fit into the table.,
# so it is less visible.
# Some are probably for Windows only.
if env_key in ["PATH", "PSMODULEPATH", "PYPATH"]:
val_split = env_val.split(os.pathsep)
nod_fil_arr = [lib_uris.gUriGen.DirectoryUri(fil_nam) for fil_nam in val_split]
nod_fil_arr_nod = lib_util.NodeLiteral(nod_fil_arr)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil_arr_nod))
elif os.path.isdir(env_val):
nod_fil = lib_uris.gUriGen.DirectoryUri(env_val)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil))
elif os.path.exists(env_val):
nod_fil = lib_uris.gUriGen.FileUri(env_val)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil))
else:
# TODO: Beware that "\L" is transformed into "<TABLE>" by Graphviz !!!
env_val_clean = env_val.replace(">", "_").replace("<", "_").replace("&", "_").replace("\\", "_")
node_env_value = lib_util.NodeLiteral(env_val_clean)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, node_env_value))
grph.add((node_process, env_prop, node_env_nam))
cgiEnv.OutCgiRdf("LAYOUT_RECT", [env_prop])
def Main():
cgiEnv = lib_common.CgiEnv()
pidProc = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_common.gUriGen.PidUri(pidProc)
proc_obj = CIM_Process.PsutilGetProcObj(pidProc)
# Now we are parsing the command line.
cmd_line = CIM_Process.PsutilProcToCmdline(proc_obj)
sys.stderr.write("cmd_line=%s\n" % str(cmd_line))
# Similar to split, but ignores white spaces in double quotes.
argvArray = re.findall(r'(?:[^\s "]|"(?:\\.|[^"])*")+', cmd_line)
sys.stderr.write("argvArray=%s\n" % str(argvArray))
# This extracts the command file name and creates a node for it.
for theArg in argvArray[1:]:
if theArg[0] == "/":
continue
# Check if the file exists in the current directory.
currPwd, errMsg = CIM_Process.PsutilProcCwd(proc_obj)
if not currPwd:
sys.stderr.write("PyFilNode: %s\n" % errMsg)
break
allDirsToSearch = [currPwd]
envPath = CIM_Process.GetEnvVarProcess("PATH", proc_obj.pid)
if envPath:
allDirsToSearch += envPath.split(";")
# Now tries all possible dirs, starting with current directory.
for aDir in allDirsToSearch:
fullScriptPath = os.path.join(aDir, theArg)
if os.path.isfile(fullScriptPath):
sys.stderr.write("fullScriptPath=%s\n" % fullScriptPath)
scriptNode = lib_common.gUriGen.FileUri(fullScriptPath)
grph.add((node_process, pc.property_runs, scriptNode))
break
break
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
try:
procid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
obj_proc = CIM_Process.PsutilGetProcObj(procid)
node_process = lib_uris.gUriGen.PidUri(procid)
CIM_Process.add_command_line_arguments(grph, node_process, obj_proc)
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def Main():
cgiEnv = lib_common.CgiEnv()
pidProc = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_common.gUriGen.PidUri(pidProc)
proc_obj = CIM_Process.PsutilGetProcObj(pidProc)
# Python 2
# cmd_arr=['C:\\Python27\\python.exe', 'test_survol_client_library.py', '--debug', 'SurvolLocalTest.test_msdos_current_batch']
# Python 3
# cmd_arr=['C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\Python36_64\\python.exe', 'test_survol_client_library.py', '--debug', 'SurvolLocalTest.test_msdos_current_batch']
argvArray = CIM_Process.PsutilProcToCmdlineArray(proc_obj)
DEBUG("argvArray=%s", str(argvArray))
# This extracts the command file name and creates a node for it.
for theArg in argvArray[1:]:
if theArg[0] == "/":
continue
# Check if the file exists in the current directory.
currPwd, errMsg = CIM_Process.PsutilProcCwd(proc_obj)
if not currPwd:
break
allDirsToSearch = [currPwd]
envPath = CIM_Process.GetEnvVarProcess("PATH", proc_obj.pid)
if envPath:
allDirsToSearch += envPath.split(";")
# Now tries all possible dirs, starting with current directory.
for aDir in allDirsToSearch:
fullScriptPath = os.path.join(aDir, theArg)
DEBUG("fullScriptPath=%s", fullScriptPath)
if os.path.isfile(fullScriptPath):
DEBUG("fullScriptPath=%s", fullScriptPath)
scriptNode = lib_common.gUriGen.FileUri(fullScriptPath)
grph.add((node_process, pc.property_runs, scriptNode))
break
break
cgiEnv.OutCgiRdf()
def Usable(entity_type, entity_ids_arr):
"""Python processes"""
pidProc = entity_ids_arr[0]
try:
# Any error, no display.
proc_obj = CIM_Process.PsutilGetProcObj(int(pidProc))
except:
return False
cmd_line = CIM_Process.PsutilProcToCmdline(proc_obj)
cmdlinSplit = cmd_line.split(" ")
execNam = cmdlinSplit[0]
basNam = os.path.basename(execNam)
# This is a python process because of the executable.
return basNam.startswith("python")
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid_proc = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_uris.gUriGen.PidUri(pid_proc)
proc_obj = CIM_Process.PsutilGetProcObj(int(pid_proc))
# Now we are parsing the command line.
argv_array = CIM_Process.PsutilProcToCmdlineArray(proc_obj)
logging.debug("argv_array=%s", str(argv_array))
# The difficulty is that filenames with spaces are split.
# Therefore, entire filenames must be rebuilt from pieces.
_add_nodes_from_command_line(argv_array, grph, node_process, proc_obj)
cgiEnv.OutCgiRdf()
def Main():
paramkeyShowSharedLib = "Show shared libraries"
paramkeyShowFontFiles = "Show font files"
cgiEnv = lib_common.CgiEnv(parameters={
paramkeyShowSharedLib: False,
paramkeyShowFontFiles: False
})
top_pid = int(cgiEnv.GetId())
flagShowSharedLib = bool(cgiEnv.get_parameters(paramkeyShowSharedLib))
flagShowFontFiles = bool(cgiEnv.get_parameters(paramkeyShowFontFiles))
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(top_pid)
# sys.stderr.write("top_pid=%d\n" % top_pid)
node_process = lib_common.gUriGen.PidUri(top_pid)
CIM_Process.AddInfo(grph, node_process, [str(top_pid)])
################################################################################
try:
fillist = CIM_Process.PsutilProcOpenFiles(proc_obj)
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught:" + str(exc) + ":" + str(proc_obj))
for fil in fillist:
# TODO: Resolve symbolic links. Do not do that if shared memory.
# TODO: AVOIDS THESE TESTS FOR SHARED MEMORY !!!!
if lib_common.is_meaningless_file(fil.path, not flagShowSharedLib,
not flagShowFontFiles):
continue
fileNode = lib_common.gUriGen.FileUri(fil.path)
grph.add((node_process, pc.property_open_file, fileNode))
# This works but not really necessary because there are not so many files.
# cgiEnv.OutCgiRdf( "", [pc.property_open_file] )
cgiEnv.OutCgiRdf("LAYOUT_SPLINE")
def Main():
cgiEnv = lib_common.CgiEnv()
try:
root_pid = int(cgiEnv.GetId())
except KeyError:
lib_common.ErrorMessageHtml("Process id should be provided")
grph = cgiEnv.GetGraph()
proc_obj = CIM_Process.PsutilGetProcObj(root_pid)
# Sub-processes, recursion.
tree_subprocesses(grph, proc_obj)
# Now display the parent processes.
# It could be done in a loop instead of recursive calls.
tree_parent_process(grph, proc_obj, set())
# This layout style, because the nodes are quite big.
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def Main():
cgiEnv = lib_common.CgiEnv()
pidProc = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_common.gUriGen.PidUri(pidProc)
proc_obj = CIM_Process.PsutilGetProcObj(int(pidProc))
# Now we are parsing the command line.
cmd_line = CIM_Process.PsutilProcToCmdline(proc_obj)
sys.stderr.write("cmd_line=%s\n" % str(cmd_line))
# Similar to split, but ignores white spaces in double quotes.
argvArray = re.findall(r'(?:[^\s "]|"(?:\\.|[^"])*")+', cmd_line)
sys.stderr.write("argvArray=%s\n" % str(argvArray))
argvArgs = " ".join(argvArray[1:])
sys.stderr.write("argvArgs=%s\n" % argvArgs)
opts, otherArgs = getopt.getopt(argvArgs, "Bc:dEhim:ORQ:sStuvVW:x3")
ignoreEnvs = False
for opt, arg in opts:
if opt == '-E':
ignoreEnvs = True
if otherArgs:
filNam = otherArgs
filNode = PyFilNode(proc_obj, filNam, ignoreEnvs)
if filNode:
grph.add((node_process, pc.property_runs, filNode))
sys.stderr.write("filNam=%s\n" % filNam)
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid_proc = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_uris.gUriGen.PidUri(pid_proc)
proc_obj = CIM_Process.PsutilGetProcObj(pid_proc)
argv_array = CIM_Process.PsutilProcToCmdlineArray(proc_obj)
logging.debug("argv_array=%s", str(argv_array))
# This extracts the command file name and creates a node for it.
for the_arg in argv_array[1:]:
if the_arg[0] == "/":
continue
# Check if the file exists in the current directory.
curr_pwd, err_msg = CIM_Process.PsutilProcCwd(proc_obj)
if not curr_pwd:
break
all_dirs_to_search = [curr_pwd]
env_path = CIM_Process.GetEnvVarProcess("PATH", proc_obj.pid)
if env_path:
all_dirs_to_search += env_path.split(";")
# Now tries all possible dirs, starting with current directory.
for a_dir in all_dirs_to_search:
full_script_path = os.path.join(a_dir, the_arg)
logging.debug("full_script_path=%s", full_script_path)
if os.path.isfile(full_script_path):
script_node = lib_uris.gUriGen.FileUri(full_script_path)
grph.add((node_process, pc.property_runs, script_node))
break
break
cgiEnv.OutCgiRdf()