Module: Rex::Ui::Text::Shell

Included in:
DispatcherShell, PseudoShell
Defined in:
lib/rex/ui/text/shell.rb

Overview

The shell class provides a command-prompt style interface in a generic fashion.

Defined Under Namespace

Modules: InputShell

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#disable_output ⇒ Object

Whether or not output has been disabled.



254
255
256
 
# File 'lib/rex/ui/text/shell.rb', line 254

def disable_output
  @disable_output
end

#input ⇒ Object

The input handle to read user input from.



258
259
260
 
# File 'lib/rex/ui/text/shell.rb', line 258

def input
  @input
end

#on_command_proc ⇒ Object

Returns the value of attribute on_command_proc.



264
265
266
 
# File 'lib/rex/ui/text/shell.rb', line 264

def on_command_proc
  @on_command_proc
end

#on_print_proc ⇒ Object

Returns the value of attribute on_print_proc.



265
266
267
 
# File 'lib/rex/ui/text/shell.rb', line 265

def on_print_proc
  @on_print_proc
end

#output ⇒ Object

The output handle to write output to.



262
263
264
 
# File 'lib/rex/ui/text/shell.rb', line 262

def output
  @output
end

Instance Method Details

#init_tab_complete ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/rex/ui/text/shell.rb', line 53

def init_tab_complete
	if (self.input and self.input.supports_readline)
		self.input = Input::Readline.new(lambda { |str| tab_complete(str) })
		if Readline::HISTORY.length == 0 and histfile and File.exists?(histfile)
			File.readlines(histfile).each { |e|
				Readline::HISTORY << e.chomp
			}
			self.hist_last_saved = Readline::HISTORY.length
		end
		self.input.output = self.output
		update_prompt(input.prompt)
	end
end

#init_ui(in_input = nil, in_output = nil) ⇒ Object

Initializes the user interface input/output classes.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/rex/ui/text/shell.rb', line 70

def init_ui(in_input = nil, in_output = nil)
	# Initialize the input and output methods
	self.input  = in_input
	self.output = in_output

	if (self.input)
		# Extend the input medium as an input shell if the input medium
		# isn't intrinsicly a shell.
		if (self.input.intrinsic_shell? == false)
			self.input.extend(InputShell)
		end

		self.input.output = self.output
	end
	update_prompt('')
end

#initialize(prompt, prompt_char = '>', histfile = nil) ⇒ Object

Initializes a shell that has a prompt and can be interacted with.



39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/rex/ui/text/shell.rb', line 39

def initialize(prompt, prompt_char = '>', histfile = nil)
	# Set the stop flag to false
	self.stop_flag      = false
	self.disable_output = false
	self.stop_count	    = 0

	# Initialize the prompt
	self.init_prompt = prompt
	self.prompt_char = prompt_char

	self.histfile = histfile
	self.hist_last_saved = 0
end

#print(msg = '') ⇒ Object

Prints a raw message to the output handle.



245
246
247
248
249
 
# File 'lib/rex/ui/text/shell.rb', line 245

def print(msg='')
	return if (disable_output == true)
	self.on_print_proc.call(msg) if self.on_print_proc
	log_output(output.print(msg))
end

#print_error(msg = '') ⇒ Object

Prints an error message to the output handle.



204
205
206
207
208
209
210
 
# File 'lib/rex/ui/text/shell.rb', line 204

def print_error(msg='')
	return if (output.nil?)

	self.on_print_proc.call(msg) if self.on_print_proc
	# Errors are not subject to disabled output
	log_output(output.print_error(msg))
end

#print_good(msg = '') ⇒ Object

Prints a good message to the output handle.



225
226
227
228
229
230
 
# File 'lib/rex/ui/text/shell.rb', line 225

def print_good(msg='')
	return if (disable_output == true)

	self.on_print_proc.call(msg) if self.on_print_proc
	log_output(output.print_good(msg))
end

#print_line(msg = '') ⇒ Object

Prints a line of text to the output handle.



235
236
237
238
239
240
 
# File 'lib/rex/ui/text/shell.rb', line 235

def print_line(msg='')
	return if (disable_output == true)

	self.on_print_proc.call(msg) if self.on_print_proc
	log_output(output.print_line(msg))
end

#print_status(msg = '') ⇒ Object

Prints a status message to the output handle.



215
216
217
218
219
220
 
# File 'lib/rex/ui/text/shell.rb', line 215

def print_status(msg='')
	return if (disable_output == true)

	self.on_print_proc.call(msg) if self.on_print_proc
	log_output(output.print_status(msg))
end

#reset_ui ⇒ Object

Resets the user interface handles.



90
91
92
 
# File 'lib/rex/ui/text/shell.rb', line 90

def reset_ui
	init_ui
end

#run(&block) ⇒ Object

Run the command processing loop.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/rex/ui/text/shell.rb', line 118

def run(&block)

	begin

		while true
			# If the stop flag was set or we've hit EOF, break out
			break if (self.stop_flag or self.stop_count > 1)

			init_tab_complete
			line = input.pgets
			log_output(input.prompt)

			# If a block was passed in, pass the line to it.  If it returns true,
			# break out of the shell loop.
			if (block)
				break if (line == nil or block.call(line))
			elsif(input.eof? or line == nil)
			# If you have sessions active, this will give you a shot to exit gravefully
			# If you really are ambitious, 2 eofs will kick this out
				self.stop_count += 1
				next if(self.stop_count > 1)
				run_single("quit")
			else
			# Otherwise, call what should be an overriden instance method to
			# process the line.
				ret = run_single(line)
				# don't bother saving lines that couldn't be found as a
				# command, create the file if it doesn't exist
				if ret and self.histfile
					File.open(self.histfile, "a+") { |f|
						f.puts(line)
					}
				end
				self.stop_count = 0
			end

		end
	# Prevent accidental console quits
	rescue ::Interrupt
		output.print("Interrupt: use the 'exit' command to quit\n")
		retry
	end
end

#set_log_source(log_source) ⇒ Object

Sets the log source that should be used for logging input and output.



97
98
99
 
# File 'lib/rex/ui/text/shell.rb', line 97

def set_log_source(log_source)
	self.log_source = log_source
end

#stop ⇒ Object

Stop processing user input.



165
166
167
 
# File 'lib/rex/ui/text/shell.rb', line 165

def stop
	self.stop_flag = true
end

#stopped? ⇒ Boolean

Checks to see if the shell has stopped.

Returns:

  • (Boolean) 


172
173
174
 
# File 'lib/rex/ui/text/shell.rb', line 172

def stopped?
	self.stop_flag
end

#tab_complete(str) ⇒ Object

Performs tab completion on the supplied string.



111
112
113
 
# File 'lib/rex/ui/text/shell.rb', line 111

def tab_complete(str)
	return tab_complete_proc(str) if (tab_complete_proc)
end

#unset_log_source ⇒ Object

Unsets the log source so that logging becomes disabled.



104
105
106
 
# File 'lib/rex/ui/text/shell.rb', line 104

def unset_log_source
	set_log_source(nil)
end

#update_prompt(prompt = nil, new_prompt_char = nil) ⇒ Object

Change the input prompt.



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/rex/ui/text/shell.rb', line 179

def update_prompt(prompt = nil, new_prompt_char = nil)
	if (self.input)
		if (prompt)
			new_prompt = self.init_prompt + ' ' + prompt + prompt_char + ' '
		else
			new_prompt = self.prompt || ''
		end

		# Save the prompt before any substitutions
		self.prompt = new_prompt

		# Set the actual prompt to the saved prompt with any substitutions
		# or updates from our output driver, be they color or whatever
		self.input.prompt = self.output.update_prompt(new_prompt)
		self.prompt_char  = new_prompt_char if (new_prompt_char)
	end
end