01 # A program to get the command lines of processes, given their PIDs.
02
03 from __future__ import print_function
04 import sys
05 from proc_info import read_proc_cmdline
06
07 from error_exit import error_exit
08
09 def main():
10     if len(sys.argv) < 2:
11         error_exit("{}: Error: Need at least one PID to process.\n".format(sys.argv[0]))
12     pids = sys.argv[1:]
13     print("Getting command lines for these PIDs:\n{}".format(' '.join(pids)))
14     for pid in pids:
15         proc_filename = "/proc/{}/cmdline".format(pid)
16         ok, result = read_proc_cmdline(proc_filename)
17         if ok:
18             sys.stdout.write("PID: {} Command line: {}\n".format(pid, result))
19         else:
20             sys.stderr.write("PID: {} Error: {}\n".format(pid, result))
21
22 if __name__ == '__main__':
23     main()

01 # A module with functions to get information from files
02 # in the /proc pseudo file system for various purposes.
03
04 from __future__ import print_function
05 import sys
06 import string
07 import pwd
08
09 from error_exit import error_exit
10
11 def read_proc_cmdline(proc_filename):
12     """
13     Function to read the command-line of a process, given its proc_filename.
14     Returns a tuple: first item of tuple is a boolean, True if successful,
15     False if not; second item of tuple is the result (cmdline) if first item
16     is True, or an error message if first item is False.
17     """
18
19     try:
20         with open(proc_filename, 'r') as proc_fil:
21             # Read cmdline value.
22             data = proc_fil.read()
23             # Make it printable.
24             ret_val = (True, data.replace('\0', ' '))
25     except IOError as ioe:
26         ret_val = (False, "IOError while opening proc file: {} ".format(str(ioe)))
27     except Exception as e:
28         ret_val = (False, "Exception: {}".format(str(xe)))
29     finally:
30         return ret_val
31
32 def read_proc_environ(proc_filename):
33     """
34     Function to read the environment of a process, given its proc_filename.
35     Returns a tuple: first item of tuple is a boolean, True if successful,
36     False if not; second item of tuple is the result (environ) if first item
37     is True, or an error message if first item is False.
38     """
39     try:
40         with open(proc_filename, 'r') as proc_fil:
41             # Read environ value.
42             data = proc_fil.read()
43             # Make it printable.
44             ret_val = (True, data.replace('\0', '\n'))
45             return ret_val
46     except IOError as ioe:
47         ret_val = (False, "IOError while opening proc file: {}".format(str(ioe)))
48     except Exception as e:
49         ret_val = (False, "Exception: {}".format(str(ioe)))
50     finally:
51         return ret_val
52
53 def read_proc_status(proc_filename):
54
55     """
56     Function to read the status of a process, given its proc_filename.
57     Returns a tuple: first item of tuple is a boolean, True if successful,
58     False if not; second item of tuple is the result (status) if first item
59     is True, or an error message if first item is False.
60     """
61     try:
62         with open(proc_filename, 'r') as proc_fil:
63             # Read desired status fields and values.
64             proc_status = {}
65             for lin in proc_fil:
66                 if lin.startswith(('Name:', 'State:', 'Pid:', 'PPid:', 'Uid:', 'Gid:')):
67                     parts = lin.split()
68                     assert len(parts) > 1
69                     proc_status[parts[0]] = parts[1]
70             assert 'Uid:' in proc_status
71             # Get username for uid.
72             uid = proc_status['Uid:']
73             pwent = pwd.getpwuid(int(uid))
74             proc_status["Username:"] = pwent.pw_name
75             ret_val = (True, proc_status)
76     except ValueError as ve:
77         ret_val = (False, "ValueError in read_proc_status(): {}".format(str(ve)))
78     except IOError as ioe:
79         ret_val = (False, "IOError in read_proc_status(): {}".format(str(ioe)))
80     except Exception as e:
81         ret_val = (False, "Exception in read_proc_status(): {}".format(str(ioe)))
82     finally:
83         return ret_val

01 # error_exit.py
02
03 # Purpose: This module, error_exit.py, defines a function with
04 # the same name, error_exit(), which takes a string message
05 # as an argument. It prints the message to sys.stderr, or
06 # to another file object open for writing (if given as the
07 # second argument), and then exits the program.
08 # The function error_exit can be used when a fatal error condition occurs,
09 # and you therefore want to print an error message and exit your program.
10
11 import sys
12
13 def error_exit(message, dest=sys.stderr):
14     dest.write(message)
15     sys.exit(1)
16
17 def main():
18     error_exit("Testing error_exit with dest sys.stderr (default).\n")
19     error_exit("Testing error_exit with dest sys.stdout.\n",
20         sys.stdout)
21     with open("temp1.txt", "w") as fil:
22         error_exit("Testing error_exit with dest temp1.txt.\n", fil)
23
24 if __name__ == "__main__":
25     main()

01 # echo_args.py
02 # Echoes the command-line arguments to the standard output.
03
04 from __future__ import print_function
05
06 import sys
07 import time
08
09 print("Arguments separated by | signs:")
10 print('|'.join(sys.argv))
11
12 # Sleep for 10 minutes; any reasonable time will do.
13 # It just needs to be enough for us to go to another terminal
14 # and run the command to read this process's arguments via /proc.
15 time.sleep(600)