This file is indexed.

/usr/bin/scp-remote is in thin-client-manager-backend 0.5.1-0ubuntu9.

This file is owned by root:root, with mode 0o755.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#!/usr/bin/python

import studentcontrolpanel.ltcm as ltcm
from gobject.option import OptionGroup, OptionParser, make_option, OptionError
from gobject import GError
import sys

parser = OptionParser("", 
    description="Thin Client Manager Backend",
    option_list = [
	make_option("--users", "-u",
		    type="string",
		    action="store",
		    dest="users",
		    help="List of users to apply section to"),

        make_option("--exec", "-e", 
                    type="string", 
                    action="store", 
                    dest="execapp",
                    help="Process to execute on users computer using --users"),

	make_option("--kill", "-k", 
		    type="string",
                    action="store", 
                    dest="kill",
                    help="Process to kill on users computer using --users"),

        make_option("--message", "-m", 
		    type="string",
                    action="store", 
                    dest="mess", 
                    help="Message to send to users using --users"),

        make_option("--lock", "-l", 
                    action="store_true", 
                    dest="lock", 
                    help="Lock selected users using --users"),

        make_option("--unlock", "-c", 
                    action="store_true", 
                    dest="unlock", 
                    help="Unlock selected users using --users"),

        make_option("--return_users", "-U", 
                    action="store_true", 
                    dest="return_users", 
                    help="Returns the current users list"),

	make_option("--return_process", "-P",
		    type="string",
		    action="store",
		    dest="return_process",
		    help="Returns the processes for the current user"),

        make_option("--lockdown_user", "-L", 
		    type="string",
                    action="store", 
                    dest="lockdown", 
                    help="Locks down selected user"),

        make_option("--disconnect", "-D", 
		    type="string",
                    action="store", 
                    dest="logout", 
                    help="Disconnect a selected pid"),

        make_option("--return_groups", "-g", 
                    action="store_true", 
                    dest="return_groups", 
                    help="Returns the groups config"),

        make_option("--write_groups", "-w", 
                    action="store_true", 
                    dest="write_groups", 
                    help="Writes group data, USE WITH CAUTION"),

	make_option("--forever", "-f",
                    action="store_true", 
                    dest="forever", 
                    help="sits here forever"),
		    

        # ...
    ])

try:
	parser.parse_args()
except GError, e:
	print "Error: " + str(e)

testing = ltcm.backend()

#Lockdown cannot be implemented I don't think

if parser.values.kill != None and parser.values.users != None:
	testing.kill_process(parser.values.kill, parser.values.users)
elif parser.values.lock != None and parser.values.users != None:
	testing.lock(parser.values.users.split(","))
elif parser.values.unlock != None and parser.values.users != None:
	testing.unlock(parser.values.users.split(","))
elif parser.values.execapp != None and parser.values.users != None:
	testing.start_process(parser.values.users.split(","), parser.values.execapp)
elif parser.values.mess != None and parser.values.users != None:
	testing.send_message(parser.values.users.split(","), parser.values.mess)
elif parser.values.logout != None:
	testing.logout_pid(parser.values.logout)
elif parser.values.return_users != None:
	users = testing.poll_userlist()
	for a in users:
		sys.stdout.write((",").join(a)+"\n")
elif parser.values.return_process != None:
	process = testing.poll_proclist(parser.values.return_process)
	for a in process:
		sys.stdout.write((",").join(a)+"\n")
elif parser.values.return_groups != None:
	process = testing.return_config()
	for a in process:
		sys.stdout.write(a)
elif parser.values.write_groups != None:
	testing.funny_write()
elif parser.values.forever != None:
	j=raw_input()