From e70b46672c9bc7a1923d121f954224930bb8af7f Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Mon, 6 Mar 2017 11:56:11 +1300 Subject: Options unification: simple string sequences --- mitmproxy/options.py | 61 ++++++++++++++++++++++++++++++----- mitmproxy/optmanager.py | 9 ++++++ mitmproxy/tools/cmdline.py | 79 +++++++--------------------------------------- 3 files changed, 73 insertions(+), 76 deletions(-) diff --git a/mitmproxy/options.py b/mitmproxy/options.py index ec270076..9d2d8e19 100644 --- a/mitmproxy/options.py +++ b/mitmproxy/options.py @@ -50,7 +50,10 @@ class Options(optmanager.OptManager): "anticomp", False, bool, "Try to convince servers to send us un-compressed data." ) - self.add_option("client_replay", [], Sequence[str]) + self.add_option( + "client_replay", [], Sequence[str], + "Replay client requests from a saved file." + ) self.add_option( "replay_kill_extra", False, bool, "Kill extra requests during replay." @@ -75,16 +78,29 @@ class Options(optmanager.OptManager): "rfile", None, Optional[str], "Read flows from file." ) - self.add_option("scripts", [], Sequence[str]) + self.add_option( + "scripts", [], Sequence[str], + """ + Run a script. Surround with quotes to pass script arguments. Can + be passed multiple times. + """ + ) self.add_option( "showhost", False, bool, "Use the Host header to construct URLs for display." ) self.add_option("replacements", [], Sequence[Union[Tuple[str, str, str], str]]) self.add_option("replacement_files", [], Sequence[Union[Tuple[str, str, str], str]]) - self.add_option("server_replay_use_headers", [], Sequence[str]) + self.add_option( + "server_replay_use_headers", [], Sequence[str], + "Request headers to be considered during replay. " + "Can be passed multiple times." + ) self.add_option("setheaders", [], Sequence[Union[Tuple[str, str, str], str]]) - self.add_option("server_replay", [], Sequence[str]) + self.add_option( + "server_replay", [], Sequence[str], + "Replay server responses from a saved file." + ) self.add_option( "stickycookie", None, Optional[str], "Set sticky cookie filter. Matched against requests." @@ -112,8 +128,21 @@ class Options(optmanager.OptManager): "server_replay_ignore_content", False, bool, "Ignore request's content while searching for a saved flow to replay." ) - self.add_option("server_replay_ignore_params", [], Sequence[str]) - self.add_option("server_replay_ignore_payload_params", [], Sequence[str]) + self.add_option( + "server_replay_ignore_params", [], Sequence[str], + """ + Request's parameters to be ignored while searching for a saved flow + to replay. Can be passed multiple times. + """ + ) + self.add_option( + "server_replay_ignore_payload_params", [], Sequence[str], + """ + Request's payload parameters (application/x-www-form-urlencoded or multipart/form-data) to + be ignored while searching for a saved flow to replay. + Can be passed multiple times. + """ + ) self.add_option( "server_replay_ignore_host", False, bool, "Ignore request's destination host while searching for a saved" @@ -163,7 +192,16 @@ class Options(optmanager.OptManager): "client_certs", None, Optional[str], "Client certificate file or directory." ) - self.add_option("ignore_hosts", [], Sequence[str]) + self.add_option( + "ignore_hosts", [], Sequence[str], + """ + Ignore host and forward all traffic without processing it. In + transparent mode, it is recommended to use an IP address (range), + not the hostname. In regular mode, only SSL traffic is ignored and + the hostname should be used. The supplied value is interpreted as a + regular expression and matched on the ip or the hostname. + """ + ) self.add_option( "listen_host", "", str, "Address to bind proxy to (defaults to all interfaces)" @@ -237,7 +275,14 @@ class Options(optmanager.OptManager): "ssl_verify_upstream_trusted_ca", None, Optional[str], "Path to a PEM formatted trusted CA certificate." ) - self.add_option("tcp_hosts", [], Sequence[str]) + self.add_option( + "tcp_hosts", [], Sequence[str], + """ + Generic TCP SSL proxy mode for all hosts that match the pattern. + Similar to --ignore, but SSL connections are intercepted. The + communication contents are printed to the log in verbose mode. + """ + ) self.add_option( "intercept", None, Optional[str], diff --git a/mitmproxy/optmanager.py b/mitmproxy/optmanager.py index b9aaf6c8..24ef8f0c 100644 --- a/mitmproxy/optmanager.py +++ b/mitmproxy/optmanager.py @@ -348,5 +348,14 @@ class OptManager: help=o.help, metavar=metavar ) + elif o.typespec == typing.Sequence[str]: + parser.add_argument( + "--%s" % f, + action="append", + type=str, + dest=option, + help=o.help, + metavar=metavar + ) else: raise ValueError("Unsupported option type: %s", o.typespec) diff --git a/mitmproxy/tools/cmdline.py b/mitmproxy/tools/cmdline.py index fc584869..0d6212bf 100644 --- a/mitmproxy/tools/cmdline.py +++ b/mitmproxy/tools/cmdline.py @@ -162,15 +162,7 @@ def basic_options(parser, opts): help="Quiet." ) opts.make_parser(parser, "rfile") - parser.add_argument( - "-s", "--script", - action="append", type=str, dest="scripts", - metavar='"script.py --bar"', - help=""" - Run a script. Surround with quotes to pass script arguments. Can be - passed multiple times. - """ - ) + opts.make_parser(parser, "scripts", metavar="SCRIPT") opts.make_parser(parser, "stickycookie", metavar="FILTER") opts.make_parser(parser, "stickyauth", metavar="FILTER") parser.add_argument( @@ -230,29 +222,8 @@ def proxy_modes(parser, opts): def proxy_options(parser, opts): group = parser.add_argument_group("Proxy Options") opts.make_parser(group, "listen_host") - group.add_argument( - "-I", "--ignore", - action="append", type=str, dest="ignore_hosts", - metavar="HOST", - help=""" - Ignore host and forward all traffic without processing it. In - transparent mode, it is recommended to use an IP address (range), - not the hostname. In regular mode, only SSL traffic is ignored and - the hostname should be used. The supplied value is interpreted as a - regular expression and matched on the ip or the hostname. Can be - passed multiple times. - """ - ) - group.add_argument( - "--tcp", - action="append", type=str, dest="tcp_hosts", - metavar="HOST", - help=""" - Generic TCP SSL proxy mode for all hosts that match the pattern. - Similar to --ignore, but SSL connections are intercepted. The - communication contents are printed to the log in verbose mode. - """ - ) + opts.make_parser(group, "ignore_hosts", metavar="HOST") + opts.make_parser(group, "tcp_hosts", metavar="HOST") opts.make_parser(group, "no_server") opts.make_parser(group, "listen_port", metavar="PORT") @@ -318,50 +289,22 @@ def onboarding_app(parser, opts): def client_replay(parser, opts): group = parser.add_argument_group("Client Replay") - group.add_argument( - "-c", "--client-replay", - action="append", dest="client_replay", metavar="PATH", - help="Replay client requests from a saved file." - ) + opts.make_parser(group, "client_replay", metavar="PATH") def server_replay(parser, opts): group = parser.add_argument_group("Server Replay") - group.add_argument( - "-S", "--server-replay", - action="append", dest="server_replay", metavar="PATH", - help="Replay server responses from a saved file." - ) - opts.make_parser(parser, "replay_kill_extra") - group.add_argument( - "--server-replay-use-header", - action="append", dest="server_replay_use_headers", type=str, - help="Request headers to be considered during replay. " - "Can be passed multiple times." - ) + opts.make_parser(group, "server_replay", metavar="PATH") + opts.make_parser(group, "replay_kill_extra") + opts.make_parser(group, "server_replay_use_headers", metavar="HEADER") opts.make_parser(group, "refresh_server_playback") opts.make_parser(group, "server_replay_nopop") + payload = group.add_mutually_exclusive_group() opts.make_parser(payload, "server_replay_ignore_content") - payload.add_argument( - "--replay-ignore-payload-param", - action="append", dest="server_replay_ignore_payload_params", type=str, - help=""" - Request's payload parameters (application/x-www-form-urlencoded or multipart/form-data) to - be ignored while searching for a saved flow to replay. - Can be passed multiple times. - """ - ) - - group.add_argument( - "--replay-ignore-param", - action="append", dest="server_replay_ignore_params", type=str, - help=""" - Request's parameters to be ignored while searching for a saved flow - to replay. Can be passed multiple times. - """ - ) - opts.make_parser(parser, "server_replay_ignore_host") + opts.make_parser(payload, "server_replay_ignore_payload_params") + opts.make_parser(payload, "server_replay_ignore_params") + opts.make_parser(payload, "server_replay_ignore_host") def replacements(parser, opts): -- cgit v1.2.3