查询进程间，父子进程，相互调用信息

#!/bin/sh

#程序描述：查询进程间，父子进程，相互调用信息
#作者:    程晓鹏
#日期：    2016.12.06

ps_exe_cmd="ps -ef";
print_column_spliter="\t"; #打印列分隔符

#查询字符串长度
#参数1： 查询的字符串
function QueryStrLen
{
  v_input="$1";
  v_result=`echo "${#v_input}" | awk '{print int($0)}'`;
  echo "$v_result";
}

#获取子字符串
#参数1：原始字符串
#参数2：开始的位置（从1开始）
#参数3：长度
function getSubStr
{
  v_result=""; #返回值
  v_input="$1";
  v_idx="$2";
  v_len="$3";

  v_result=`echo "${v_input}" | awk '{print substr($0, vv_idx, vv_len)}' vv_idx=${v_idx} vv_len=${v_len}`;
  echo "$v_result"
}

#查询索引值
#参数1：要查询的原始字符串
#参数2：查询的关键字
#返回值：0:代表没有搜索到；大于0，代表搜索到的索引值
function queryIndex
{
  v_result=0; #返回值
  v_str="$1";
  v_key="$2";

  v_str_len=$(QueryStrLen "${v_str}");
  v_key_len=$(QueryStrLen "${v_key}");

  if [ $v_str_len -gt 0 ] && [ $v_key_len -gt 0 ]; then
    v_result=`echo "${v_str}" | awk '{print index($0, q_key)}' q_key=${v_key}`;
  fi;

  echo $v_result;
}

#查询进程ID
#参数1：字符串
function queryProcessID
{
  v_result=""; #返回结果
  v_input="$1";
  v_result=`echo ${v_input} | awk '{print $2}'`;
  echo "$v_result";
}

#查询父进程ID
#参数1：字符串
function queryPProcessID
{
  v_result=""; #返回结果
  v_input="$1";
  v_result=`echo ${v_input} | awk '{print $3}'`;
  echo "$v_result";
}


#查询进程用户
#参数1：字符串
function queryProcessUser
{
  v_result=""; #返回结果
  v_input="$1";
  v_result=`echo ${v_input} | awk '{print $1}'`;
  echo "$v_result";
}

#查询进程名称
#参数1：要查找的字符串
#参数2：查询的关键字
function queryProcessName_exec
{
  v_result=""; #返回结果
  v_input="${1}";
  v_key="${2}";
  v_input_len=$(QueryStrLen "${v_input}");
  v_idx=$(queryIndex "${v_input}" "${v_key}");

  if [ v_idx -gt 0 ]; then
    v_len=`expr "$v_input_len" - "$v_idx" + 1 | bc`;
    v_result=$(getSubStr "${v_input}" "$v_idx" "$v_len");
  fi;

  echo "${v_result}";
}

#获取进程名称
#参数1：字符串
function queryProcessName
{
  v_result=""; #返回结果
  v_input="$1";
  v_exe_name=`echo "${v_input}" | awk '{print $8}'`; #查询进程名称，开始字符串
  v_len=$(QueryStrLen "${v_exe_name}");
  if [ $v_len -gt 0 ]; then
    v_result=$(queryProcessName_exec "${v_input}" "${v_exe_name}");
  fi;

  echo "${v_result}";
}

#清除所有空格
#参数1：所有字符串
function CleanSpace
{
  v_in_str="$1";
  echo "$v_in_str" | sed s/[[:space:]]//g;
}

#打印输出信息头
function PrintHead
{
  column_1="user";
  column_2="pid";
  column_3="ppid";
  column_4="cmd";
  col_char="$print_column_spliter"; #列分隔符

  echo "${column_1}${col_char}${column_2}${col_char}${column_3}${col_char}${column_4}";
}

#打印数据
#参数1: 字符串
function PrintItem
{
  line="$1"; #入参数据
  q_user=$(queryProcessUser "$line");
  q_pid=$(queryProcessID "$line");
  q_ppid=$(queryPProcessID "$line");
  q_pname=$(queryProcessName "$line");
  col_char=${print_column_spliter}; #列分隔符

  echo "${q_user}${col_char}${q_pid}${col_char}${q_ppid}${col_char}${q_pname}";
}

#获取子进程
#参数1：进程ID
function queryChildInfo
{
  pid="$1"; #进程ID
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($3==q_key){print $0}}' q_key=$pid`; #根据父进程ID，进行搜索
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    echo "$query_result" | while read line
    do
      out=$(PrintItem "${line}");
      echo "${out}";
      q_pid=$(queryProcessID "${line}"); #获取进程ID
      queryChildInfo "$q_pid"; #进行递归调用
    done;
  fi;
}


#获取父进程
#参数1：进程ID
function queryParentInfo
{
  pid="$1"; #进程ID
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$pid`; #根据进程ID，进行搜索
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    echo "$query_result" | while read line
    do
      out=$(PrintItem "${line}");
      echo "${out}";
      q_ppid=$(queryPProcessID "${line}"); #获取父进程ID
      queryParentInfo "$q_ppid"; #进行递归调用
    done;
  fi;
}

#是否展示，标题头信息
#参数1：是否打印标题(0:不打印; 1:打印)
function showTitle
{
  v_head="$1";
  if [ $v_head -gt 0 ]; then
    PrintHead; #打印信息头
  fi;
}

#执行查询(当前进程，及子进程)
#参数1: 查询结果
#参数2：是否打印标题(0:不打印; 1:打印)
function query_run
{
  query_result="$1";
  v_head="$2";
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    showTitle "$v_head";
    echo "$query_result" | while read line #循环处理数据
    do
      tmp_line=${line}; #临时变量，递归时调用
      q_pid=$(queryProcessID "${tmp_line}");
      queryChildInfo "$q_pid"; #获取子进程信息

      out=$(PrintItem "${tmp_line}"); #打印当前进程
      echo "${out}";
    done;
  fi;
}

#开始执行，进程追踪
#参数1: 查询结果
#参数2：是否打印标题(0:不打印; 1:打印)
function query_parent_run
{
  query_result="$1";
  v_head="$2";
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    showTitle "$v_head";
    #处理父进程，相关信息
    echo "$query_result" | while read line #循环处理数据
    do
      out=$(PrintItem "${line}"); #打印当前进程
      echo "${out}";

      q_ppid=$(queryPProcessID "${line}");
      queryParentInfo "$q_ppid"; #获取父进程信息
    done;
  fi;
}

#开始追踪，父子进程的，所有关系
#参数1: 查询结果
#参数2：是否打印标题(0:不打印; 1:打印)
function query_all_run
{
  query_result="$1";
  v_head="$2";
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    showTitle "$v_head";
    echo "$query_result" | while read line #循环处理数据
    do
      tmp_line=${line}; #临时变量，递归时调用
      tmp2_line=${line}; #临时变量，递归时调用

      q_pid=$(queryProcessID "${tmp_line}");
      queryChildInfo "$q_pid"; #获取子进程信息

      out=$(PrintItem "${tmp_line}"); #打印当前进程
      echo "${out}";

      q_ppid=$(queryPProcessID "${tmp2_line}");
      queryParentInfo "$q_ppid"; #获取父进程信息
    done;
  fi;
}

#查询自身进程
#参数1: 查询结果
#参数2：是否打印标题(0:不打印; 1:打印)
function query_self_run
{
  query_result="$1";
  v_head="$2";
  tmp_result="$1"; #临时变量
  v_len_size=$(QueryStrLen "$query_result");
  if [ $v_len_size -gt 0 ]; then
    showTitle "$v_head";
    #输出进程相关信息
    echo "$tmp_result" | while read line #循环处理数据
    do
      out=$(PrintItem "${line}");
      echo "${out}";
    done;
  fi;
}

#根据关键字,进行查询
#参数1：查询关键字
#参数2：是否打印标题(0:不打印; 1:打印)
#参数3：过滤掉的数据
function query_key
{
  v_key="$1"; #查询关键字
  v_head="$2";
  v_filter="$3";
  query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  query_run "${query_result}" "$v_head";
}

#根据进程id,进行查询
#参数1：进程ID
#参数2：是否打印标题(0:不打印; 1:打印)
function query_pid
{
  p_id="$1"; #进程id
  v_head="$2";
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  query_run "${query_result}" "$v_head";
}

#通过关键字，追踪进程的调用关系
#参数1：查询关键字
#参数2：是否打印标题(0:不打印; 1:打印)
#参数3：过滤掉的数据
function query_parent_key
{
  v_key="$1"; #查询关键字
  v_head="$2";
  v_filter="$3";
  query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  query_parent_run "${query_result}" "$v_head";
}

#通过进程id，追踪进程的父子进程，关系
#参数1：进程
#参数2：是否打印标题(0:不打印; 1:打印)
function query_parent_pid
{
  p_id="$1"; #查询关键字
  v_head="$2";
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  query_parent_run "${query_result}" "$v_head";
}

#通过进程，追踪进程的调用关系
#参数1：查询关键字
#参数2：是否打印标题(0:不打印; 1:打印)
#参数3：过滤掉的数据
function query_all_key
{
  v_key="$1"; #查询关键字
  v_head="$2";
  v_filter="$3";
  query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  query_all_run "${query_result}" "$v_head";
}

#通过进程ID，追踪进程的父子进程，关系
#参数1：进程ID
#参数2：是否打印标题(0:不打印; 1:打印)
function query_all_pid
{
  p_id="$1"; #查询关键字
  v_head="$2";
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  query_all_run "${query_result}" "$v_head";
}

#根据关键字，查询自己进程
#参数1：查询关键字
#参数2：是否打印标题(0:不打印; 1:打印)
#参数3：过滤掉的数据
function query_self_key
{
  v_key="$1"; #查询关键字
  v_head="$2";
  v_filter="$3";
  query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  query_self_run "${query_result}" "$v_head";
}

#根据进程ID,查询自己进程
#参数1：进程ID
#参数2：是否打印标题(0:不打印; 1:打印)
function query_self_pid
{
  p_id="$1"; #查询关键字
  v_head="$2";
  query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  query_self_run "${query_result}" "$v_head";
}

#################################################################################################
#################################################################################################
#################################################################################################

#帮助
#参数1：命令名称
function help
{
  v_name="$1";
  echo "${v_name}程序,为方便查询，进程调用关系的程序。核心代码为通过ps命令，通过递归方式，查找其父子进程相关参数信息。
        执行命令格式为 ${v_name} [-a] [-i] [-p] [-0] [-n] 要查询的参数
        默认为查询入参的进程及子进程。
        可选参数如下：
        -a  搜索父子进程调用关系
        -i  通过进程ID(pid)，进行搜索
        -p  查询调用的父进程调用关系
        -0  仅查询当前进程
        -n  隐藏标题输出";
}

#验证参数
#参数1：参数集合，字符串
#参数2：要验证的字符
#返回值：0：不含有该参数; 1:含有该参数
function valid_parameter
{
  v_result=0;
  v_str=`echo "$1" | tr '[A-Z]' '[a-z]'`;
  v_key=`echo "$2" | tr '[A-Z]' '[a-z]'`;

  v_idx=$(queryIndex "${v_str}" "${v_key}");
  if [ $v_idx -gt 0 ]; then
    v_result=1;
  fi;

  echo $v_result;
}

#开始运行(参数：a)
#参数1：是否通过，进程id，进行查询
#参数2：是否输出标题
#参数3：查询关键字
#参数4：需要过滤的关键字
function run_a
{
  v_pid="$1";
  v_title="$2";
  v_key="$3";
  v_filter="$4";

  if [ $v_pid -gt 0 ]; then
    query_all_pid "${v_key}" "$v_title";
  else
    query_all_key "${v_key}" "$v_title" "${v_filter}";
  fi;
}

#开始运行(参数：p)
#参数1：是否通过，进程id，进行查询
#参数2：是否输出标题
#参数3：查询关键字
#参数4：需要过滤的关键字
function run_p
{
  v_pid="$1";
  v_title="$2";
  v_key="$3";
  v_filter="$4";

  if [ $v_pid -gt 0 ]; then
    query_parent_pid "${v_key}" "$v_title";
  else
    query_parent_key "${v_key}" "$v_title" "${v_filter}";
  fi;
}

#开始运行(参数：0)
#参数1：是否通过，进程id，进行查询
#参数2：是否输出标题
#参数3：查询关键字
#参数4：需要过滤的关键字
function run_0
{
  v_pid="$1";
  v_title="$2";
  v_key="$3";
  v_filter="$4";

  if [ $v_pid -gt 0 ]; then
    query_self_pid "${v_key}" "$v_title";
  else
    query_self_key "${v_key}" "$v_title" "${v_filter}";
  fi;
}

#开始运行(默认输出进程，以及子进程信息)
#参数1：是否通过，进程id，进行查询
#参数2：是否输出标题
#参数3：查询关键字
#参数4：需要过滤的关键字
function run_default
{
  v_pid="$1";
  v_title="$2";
  v_key="$3";
  v_filter="$4";

  if [ $v_pid -gt 0 ]; then
    query_pid "${v_key}" "$v_title";
  else
    query_key "${v_key}" "$v_title" "${v_filter}";
  fi;
}

#开始运行
#参数1：是否执行所有(入参:a)
#参数2：是否通过pid，进行查询(入参:i)
#参数3：是否查询父进程相关信息(入参:p)
#参数4：是否仅查询自己的进程(入参:0)
#参数5：是否输出标题(入参:n)
#参数6：查询参数
#参数7：执行shell的名称
function run
{
  v_a="$1";
  v_i="$2";
  v_p="$3";
  v_0="$4";
  v_n="$5";
  v_key="$6";
  v_exe="$7";

  if [ $v_a -gt 0 ]; then
    run_a "$v_i" "$v_n" "${v_key}" "${v_exe}";
  elif [ $v_p -gt 0 ]; then
    run_p "$v_i" "$v_n" "${v_key}" "${v_exe}";
  elif [ $v_0 -gt 0 ]; then
    run_0 "$v_i" "$v_n" "${v_key}" "${v_exe}";
  else
    run_default "$v_i" "$v_n" "${v_key}" "${v_exe}";
  fi;
}

exe_name=$0;
all_paras_str="";
query_key="";
v_head=1; #默认输出标题

if [ $# -gt 0 ]; then
  while [ $# -ne 1 ]
  do
    para_item="$1";
    all_paras_str="${all_paras_str}${para_item}";
    shift;
  done;

  query_key="$1";
  #验证入参信息
  valid_a=$(valid_parameter "${all_paras_str}" "a"); #查看关联的，父子进程
  valid_i=$(valid_parameter "${all_paras_str}" "i"); #根据pid，进行查询
  valid_p=$(valid_parameter "${all_paras_str}" "p"); #查看父进程
  valid_0=$(valid_parameter "${all_paras_str}" "0"); #仅查询自己的进程，无关联信息
  valid_n=$(valid_parameter "${all_paras_str}" "n"); #不输出标题
  if [ $valid_n -gt 0 ]; then
    v_head=0; #关闭输出，标题信息
  fi;

  run "$valid_a" "$valid_i" "$valid_p" "$valid_0" "$v_head" "${query_key}" "${exe_name}"; #开始查询
else
  help "$exe_name";
fi;

QueryProcessInfo.rar