winrm 2.1.0 → 2.1.1

data/lib/winrm/psrp/receive_response_reader.rb

@@ -1,97 +1,97 @@
-# -*- encoding: utf-8 -*-
-#
-# Copyright 2016 Matt Wrock <matt@mattwrock.com>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'nori'
-require_relative 'powershell_output_decoder'
-require_relative 'message_defragmenter'
-
-module WinRM
-  module PSRP
-    # Class for reading powershell responses in Receive_Response messages
-    class ReceiveResponseReader < WSMV::ReceiveResponseReader
-      # Creates a new ReceiveResponseReader
-      # @param transport [HttpTransport] The WinRM SOAP transport
-      # @param logger [Logger] The logger to log diagnostic messages to
-      def initialize(transport, logger)
-        super
-        @output_decoder = PowershellOutputDecoder.new
-      end
-
-      # Reads PSRP messages sent in one or more receive response messages
-      # @param wsmv_message [WinRM::WSMV::Base] A wsmv message to send to endpoint
-      # @param wait_for_done_state whether to poll for a CommandState of Done
-      # @yield [Message] PSRP Message in response
-      # @yieldreturn [Array<Message>] All messages in response
-      def read_message(wsmv_message, wait_for_done_state = false)
-        messages = []
-        defragmenter = MessageDefragmenter.new
-        read_response(wsmv_message, wait_for_done_state) do |stream|
-          message = defragmenter.defragment(stream[:text])
-          next unless message
-          if block_given?
-            yield message
-          else
-            messages.push(message)
-          end
-        end
-        messages unless block_given?
-      end
-
-      # Reads streams and returns decoded output
-      # @param wsmv_message [WinRM::WSMV::Base] A wsmv message to send to endpoint
-      # @yieldparam [string] standard out response text
-      # @yieldparam [string] standard error response text
-      # @yieldreturn [WinRM::Output] The command output
-      def read_output(wsmv_message)
-        with_output do |output|
-          read_message(wsmv_message, true) do |message|
-            exit_code = find_exit_code(message)
-            output.exitcode = exit_code if exit_code
-            decoded_text = @output_decoder.decode(message)
-            next unless decoded_text
-            out = { stream_type(message) => decoded_text }
-            output << out
-            yield [out[:stdout], out[:stderr]] if block_given?
-          end
-        end
-      end
-
-      private
-
-      def stream_type(message)
-        type = :stdout
-        case message.type
-        when WinRM::PSRP::Message::MESSAGE_TYPES[:error_record]
-          type = :stderr
-        when WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call]
-          type = :stderr if message.data.include?('WriteError')
-        when WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state]
-          if message.parsed_data.pipeline_state == WinRM::PSRP::MessageData::PipelineState::FAILED
-            type = :stderr
-          end
-        end
-        type
-      end
-
-      def find_exit_code(message)
-        parsed = message.parsed_data
-        return nil unless parsed.is_a?(MessageData::PipelineHostCall)
-
-        parsed.method_parameters[:i32].to_i if parsed.method_identifier == 'SetShouldExit'
-      end
-    end
-  end
-end
+# -*- encoding: utf-8 -*-
+#
+# Copyright 2016 Matt Wrock <matt@mattwrock.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'nori'
+require_relative 'powershell_output_decoder'
+require_relative 'message_defragmenter'
+
+module WinRM
+  module PSRP
+    # Class for reading powershell responses in Receive_Response messages
+    class ReceiveResponseReader < WSMV::ReceiveResponseReader
+      # Creates a new ReceiveResponseReader
+      # @param transport [HttpTransport] The WinRM SOAP transport
+      # @param logger [Logger] The logger to log diagnostic messages to
+      def initialize(transport, logger)
+        super
+        @output_decoder = PowershellOutputDecoder.new
+      end
+
+      # Reads PSRP messages sent in one or more receive response messages
+      # @param wsmv_message [WinRM::WSMV::Base] A wsmv message to send to endpoint
+      # @param wait_for_done_state whether to poll for a CommandState of Done
+      # @yield [Message] PSRP Message in response
+      # @yieldreturn [Array<Message>] All messages in response
+      def read_message(wsmv_message, wait_for_done_state = false)
+        messages = []
+        defragmenter = MessageDefragmenter.new
+        read_response(wsmv_message, wait_for_done_state) do |stream|
+          message = defragmenter.defragment(stream[:text])
+          next unless message
+          if block_given?
+            yield message
+          else
+            messages.push(message)
+          end
+        end
+        messages unless block_given?
+      end
+
+      # Reads streams and returns decoded output
+      # @param wsmv_message [WinRM::WSMV::Base] A wsmv message to send to endpoint
+      # @yieldparam [string] standard out response text
+      # @yieldparam [string] standard error response text
+      # @yieldreturn [WinRM::Output] The command output
+      def read_output(wsmv_message)
+        with_output do |output|
+          read_message(wsmv_message, true) do |message|
+            exit_code = find_exit_code(message)
+            output.exitcode = exit_code if exit_code
+            decoded_text = @output_decoder.decode(message)
+            next unless decoded_text
+            out = { stream_type(message) => decoded_text }
+            output << out
+            yield [out[:stdout], out[:stderr]] if block_given?
+          end
+        end
+      end
+
+      private
+
+      def stream_type(message)
+        type = :stdout
+        case message.type
+        when WinRM::PSRP::Message::MESSAGE_TYPES[:error_record]
+          type = :stderr
+        when WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call]
+          type = :stderr if message.data.include?('WriteError')
+        when WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state]
+          if message.parsed_data.pipeline_state == WinRM::PSRP::MessageData::PipelineState::FAILED
+            type = :stderr
+          end
+        end
+        type
+      end
+
+      def find_exit_code(message)
+        parsed = message.parsed_data
+        return nil unless parsed.is_a?(MessageData::PipelineHostCall)
+
+        parsed.method_parameters[:i32].to_i if parsed.method_identifier == 'SetShouldExit'
+      end
+    end
+  end
+end

data/lib/winrm/psrp/session_capability.xml.erb

@@ -1,7 +1,7 @@
-<Obj RefId="0">
-  <MS>
-    <Version N="protocolversion">2.3</Version>
-    <Version N="PSVersion">2.0</Version>
-    <Version N="SerializationVersion">1.1.0.1</Version>
-  </MS>
-</Obj>
+<Obj RefId="0">
+  <MS>
+    <Version N="protocolversion">2.3</Version>
+    <Version N="PSVersion">2.0</Version>
+    <Version N="SerializationVersion">1.1.0.1</Version>
+  </MS>
+</Obj>

data/lib/winrm/psrp/uuid.rb

@@ -1,40 +1,40 @@
-# encoding: UTF-8
-#
-# Copyright 2016 Shawn Neal <sneal@sneal.net>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module WinRM
-  module PSRP
-    # UUID helper methods
-    module UUID
-      # Format a UUID into a GUID compatible byte array for Windows
-      #
-      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa373931(v=vs.85).aspx
-      # typedef struct _GUID {
-      #   DWORD Data1;
-      #   WORD  Data2;
-      #   WORD  Data3;
-      #   BYTE  Data4[8];
-      # } GUID;
-      #
-      # @param uuid [String] Canonical hex format with hypens.
-      # @return [Array<byte>] UUID in a Windows GUID compatible byte array layout.
-      def uuid_to_windows_guid_bytes(uuid)
-        return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] unless uuid
-        b = uuid.scan(/[0-9a-fA-F]{2}/).map { |x| x.to_i(16) }
-        b[0..3].reverse + b[4..5].reverse + b[6..7].reverse + b[8..15]
-      end
-    end
-  end
-end
+# encoding: UTF-8
+#
+# Copyright 2016 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module WinRM
+  module PSRP
+    # UUID helper methods
+    module UUID
+      # Format a UUID into a GUID compatible byte array for Windows
+      #
+      # https://msdn.microsoft.com/en-us/library/windows/desktop/aa373931(v=vs.85).aspx
+      # typedef struct _GUID {
+      #   DWORD Data1;
+      #   WORD  Data2;
+      #   WORD  Data3;
+      #   BYTE  Data4[8];
+      # } GUID;
+      #
+      # @param uuid [String] Canonical hex format with hypens.
+      # @return [Array<byte>] UUID in a Windows GUID compatible byte array layout.
+      def uuid_to_windows_guid_bytes(uuid)
+        return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] unless uuid
+        b = uuid.scan(/[0-9a-fA-F]{2}/).map { |x| x.to_i(16) }
+        b[0..3].reverse + b[4..5].reverse + b[6..7].reverse + b[8..15]
+      end
+    end
+  end
+end

data/lib/winrm/shells/base.rb

@@ -1,180 +1,180 @@
-# -*- encoding: utf-8 -*-
-#
-# Copyright 2016 Shawn Neal <sneal@sneal.net>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require_relative 'retryable'
-require_relative '../http/transport'
-require_relative '../wsmv/cleanup_command'
-require_relative '../wsmv/close_shell'
-require_relative '../wsmv/command'
-require_relative '../wsmv/command_output'
-require_relative '../wsmv/receive_response_reader'
-require_relative '../wsmv/create_shell'
-require_relative '../wsmv/soap'
-
-module WinRM
-  module Shells
-    # Base class for remote shell
-    class Base
-      TOO_MANY_COMMANDS = '2150859174'.freeze
-      ERROR_OPERATION_ABORTED = '995'.freeze
-
-      FAULTS_FOR_RESET = [
-        '2150858843', # Shell has been closed
-        '2147943418', # Error reading registry key
-        TOO_MANY_COMMANDS, # Maximum commands per user exceeded
-      ].freeze
-
-      include Retryable
-
-      # Create a new Cmd shell
-      # @param connection_opts [ConnectionOpts] The WinRM connection options
-      # @param transport [HttpTransport] The WinRM SOAP transport
-      # @param logger [Logger] The logger to log diagnostic messages to
-      # @param shell_opts [Hash] Options targeted for the created shell
-      def initialize(connection_opts, transport, logger, shell_opts = {})
-        @connection_opts = connection_opts
-        @transport = transport
-        @logger = logger
-        @shell_opts = shell_opts
-      end
-
-      # @return [String] shell id of the currently opn shell or nil if shell is closed
-      attr_reader :shell_id
-
-      # @return [String] uri that SOAP calls use to identify shell type
-      attr_reader :shell_uri
-
-      # @return [ConnectionOpts] connection options of the shell
-      attr_reader :connection_opts
-
-      # @return [WinRM::HTTP::HttpTransport] transport used to talk with endpoint
-      attr_reader :transport
-
-      # @return [Logger] logger used for diagnostic messages
-      attr_reader :logger
-
-      # @return [Hash] Options targeted for the created shell
-      attr_reader :shell_opts
-
-      # Runs the specified command with optional arguments
-      # @param command [String] The command or executable to run
-      # @param arguments [Array] The optional command arguments
-      # @param block [&block] The optional callback for any realtime output
-      # @yieldparam [string] standard out response text
-      # @yieldparam [string] standard error response text
-      # @yieldreturn [WinRM::Output] The command output
-      def run(command, arguments = [], &block)
-        with_command_shell(command, arguments) do |shell, cmd|
-          response_reader.read_output(command_output_message(shell, cmd), &block)
-        end
-      end
-
-      # Closes the shell if one is open
-      def close
-        return unless shell_id
-        self.class.close_shell(connection_opts, transport, shell_id)
-        remove_finalizer
-        @shell_id = nil
-      end
-
-      protected
-
-      def send_command(_command, _arguments)
-        raise NotImplementedError
-      end
-
-      def response_reader
-        raise NotImplementedError
-      end
-
-      def open_shell
-        raise NotImplementedError
-      end
-
-      def out_streams
-        raise NotImplementedError
-      end
-
-      def command_output_message(shell_id, command_id)
-        cmd_out_opts = {
-          shell_id: shell_id,
-          command_id: command_id,
-          shell_uri: shell_uri,
-          out_streams: out_streams
-        }
-        WinRM::WSMV::CommandOutput.new(connection_opts, cmd_out_opts)
-      end
-
-      def with_command_shell(command, arguments = [])
-        tries ||= 2
-
-        open unless shell_id
-        command_id = send_command(command, arguments)
-        logger.debug("[WinRM] creating command_id: #{command_id} on shell_id #{shell_id}")
-        yield shell_id, command_id
-      rescue WinRMWSManFault => e
-        raise unless FAULTS_FOR_RESET.include?(e.fault_code) && (tries -= 1) > 0
-        reset_on_error(e)
-        retry
-      ensure
-        cleanup_command(command_id) if command_id
-      end
-
-      private
-
-      def reset_on_error(error)
-        close if error.fault_code == TOO_MANY_COMMANDS
-        logger.debug('[WinRM] opening new shell since the current one was deleted')
-        @shell_id = nil
-      end
-
-      def cleanup_command(command_id)
-        logger.debug("[WinRM] cleaning up command_id: #{command_id} on shell_id #{shell_id}")
-        cleanup_msg = WinRM::WSMV::CleanupCommand.new(
-          connection_opts,
-          shell_uri: shell_uri,
-          shell_id: shell_id,
-          command_id: command_id)
-        transport.send_request(cleanup_msg.build)
-      rescue WinRMWSManFault => e
-        raise unless e.fault_code == ERROR_OPERATION_ABORTED
-      rescue WinRMHTTPTransportError => t
-        # dont let the cleanup raise so we dont lose any errors from the command
-        logger.info("[WinRM] #{t.status_code} returned in cleanup with error: #{t.message}")
-      end
-
-      def open
-        close
-        retryable(connection_opts[:retry_limit], connection_opts[:retry_delay]) do
-          logger.debug("[WinRM] opening remote shell on #{connection_opts[:endpoint]}")
-          @shell_id = open_shell
-        end
-        logger.debug("[WinRM] remote shell created with shell_id: #{shell_id}")
-        add_finalizer
-      end
-
-      def add_finalizer
-        ObjectSpace.define_finalizer(
-          self,
-          self.class.finalize(connection_opts, transport, shell_id))
-      end
-
-      def remove_finalizer
-        ObjectSpace.undefine_finalizer(self)
-      end
-    end
-  end
-end
+# -*- encoding: utf-8 -*-
+#
+# Copyright 2016 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'retryable'
+require_relative '../http/transport'
+require_relative '../wsmv/cleanup_command'
+require_relative '../wsmv/close_shell'
+require_relative '../wsmv/command'
+require_relative '../wsmv/command_output'
+require_relative '../wsmv/receive_response_reader'
+require_relative '../wsmv/create_shell'
+require_relative '../wsmv/soap'
+
+module WinRM
+  module Shells
+    # Base class for remote shell
+    class Base
+      TOO_MANY_COMMANDS = '2150859174'.freeze
+      ERROR_OPERATION_ABORTED = '995'.freeze
+
+      FAULTS_FOR_RESET = [
+        '2150858843', # Shell has been closed
+        '2147943418', # Error reading registry key
+        TOO_MANY_COMMANDS, # Maximum commands per user exceeded
+      ].freeze
+
+      include Retryable
+
+      # Create a new Cmd shell
+      # @param connection_opts [ConnectionOpts] The WinRM connection options
+      # @param transport [HttpTransport] The WinRM SOAP transport
+      # @param logger [Logger] The logger to log diagnostic messages to
+      # @param shell_opts [Hash] Options targeted for the created shell
+      def initialize(connection_opts, transport, logger, shell_opts = {})
+        @connection_opts = connection_opts
+        @transport = transport
+        @logger = logger
+        @shell_opts = shell_opts
+      end
+
+      # @return [String] shell id of the currently opn shell or nil if shell is closed
+      attr_reader :shell_id
+
+      # @return [String] uri that SOAP calls use to identify shell type
+      attr_reader :shell_uri
+
+      # @return [ConnectionOpts] connection options of the shell
+      attr_reader :connection_opts
+
+      # @return [WinRM::HTTP::HttpTransport] transport used to talk with endpoint
+      attr_reader :transport
+
+      # @return [Logger] logger used for diagnostic messages
+      attr_reader :logger
+
+      # @return [Hash] Options targeted for the created shell
+      attr_reader :shell_opts
+
+      # Runs the specified command with optional arguments
+      # @param command [String] The command or executable to run
+      # @param arguments [Array] The optional command arguments
+      # @param block [&block] The optional callback for any realtime output
+      # @yieldparam [string] standard out response text
+      # @yieldparam [string] standard error response text
+      # @yieldreturn [WinRM::Output] The command output
+      def run(command, arguments = [], &block)
+        with_command_shell(command, arguments) do |shell, cmd|
+          response_reader.read_output(command_output_message(shell, cmd), &block)
+        end
+      end
+
+      # Closes the shell if one is open
+      def close
+        return unless shell_id
+        self.class.close_shell(connection_opts, transport, shell_id)
+        remove_finalizer
+        @shell_id = nil
+      end
+
+      protected
+
+      def send_command(_command, _arguments)
+        raise NotImplementedError
+      end
+
+      def response_reader
+        raise NotImplementedError
+      end
+
+      def open_shell
+        raise NotImplementedError
+      end
+
+      def out_streams
+        raise NotImplementedError
+      end
+
+      def command_output_message(shell_id, command_id)
+        cmd_out_opts = {
+          shell_id: shell_id,
+          command_id: command_id,
+          shell_uri: shell_uri,
+          out_streams: out_streams
+        }
+        WinRM::WSMV::CommandOutput.new(connection_opts, cmd_out_opts)
+      end
+
+      def with_command_shell(command, arguments = [])
+        tries ||= 2
+
+        open unless shell_id
+        command_id = send_command(command, arguments)
+        logger.debug("[WinRM] creating command_id: #{command_id} on shell_id #{shell_id}")
+        yield shell_id, command_id
+      rescue WinRMWSManFault => e
+        raise unless FAULTS_FOR_RESET.include?(e.fault_code) && (tries -= 1) > 0
+        reset_on_error(e)
+        retry
+      ensure
+        cleanup_command(command_id) if command_id
+      end
+
+      private
+
+      def reset_on_error(error)
+        close if error.fault_code == TOO_MANY_COMMANDS
+        logger.debug('[WinRM] opening new shell since the current one was deleted')
+        @shell_id = nil
+      end
+
+      def cleanup_command(command_id)
+        logger.debug("[WinRM] cleaning up command_id: #{command_id} on shell_id #{shell_id}")
+        cleanup_msg = WinRM::WSMV::CleanupCommand.new(
+          connection_opts,
+          shell_uri: shell_uri,
+          shell_id: shell_id,
+          command_id: command_id)
+        transport.send_request(cleanup_msg.build)
+      rescue WinRMWSManFault => e
+        raise unless e.fault_code == ERROR_OPERATION_ABORTED
+      rescue WinRMHTTPTransportError => t
+        # dont let the cleanup raise so we dont lose any errors from the command
+        logger.info("[WinRM] #{t.status_code} returned in cleanup with error: #{t.message}")
+      end
+
+      def open
+        close
+        retryable(connection_opts[:retry_limit], connection_opts[:retry_delay]) do
+          logger.debug("[WinRM] opening remote shell on #{connection_opts[:endpoint]}")
+          @shell_id = open_shell
+        end
+        logger.debug("[WinRM] remote shell created with shell_id: #{shell_id}")
+        add_finalizer
+      end
+
+      def add_finalizer
+        ObjectSpace.define_finalizer(
+          self,
+          self.class.finalize(connection_opts, transport, shell_id))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer(self)
+      end
+    end
+  end
+end