wifi-wand 2.4.0

data/lib/wifi-wand/main.rb

@@ -0,0 +1,66 @@
+require_relative 'command_line_interface'
+require_relative 'operating_systems'
+
+
+module WifiWand
+
+  require 'json'
+  require 'optparse'
+  require 'ostruct'
+  require 'yaml'
+
+  class Main
+
+    # Parses the command line with Ruby's internal 'optparse'.
+    # Looks for "-v" flag to set verbosity to true.
+    # optparse removes what it processes from ARGV, which simplifies our command parsing.
+    def parse_command_line
+      options = OpenStruct.new
+      OptionParser.new do |parser|
+        parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          options.verbose = v
+        end
+
+        parser.on("-s", "--shell", "Start interactive shell") do |v|
+          options.interactive_mode = true
+        end
+
+        parser.on("-o", "--output_format FORMAT", "Format output data") do |v|
+
+          transformers = {
+              'i' => ->(object) { object.inspect },
+              'j' => ->(object) { JSON.pretty_generate(object) },
+              'p' => ->(object) { sio = StringIO.new; sio.puts(object); sio.string },
+              'y' => ->(object) { object.to_yaml }
+          }
+
+          choice = v[0].downcase
+
+          unless transformers.keys.include?(choice)
+            raise %Q{Output format "#{choice}" not in list of available formats} +
+                      " (#{transformers.keys.inspect})."
+          end
+
+          options.post_processor = transformers[choice]
+        end
+
+        parser.on("-h", "--help", "Show help") do |_help_requested|
+          ARGV << 'h' # pass on the request to the command processor
+        end
+      end.parse!
+      options
+    end
+
+
+    def call
+      operating_systems = OperatingSystems.new
+      unless operating_systems.current_id == :mac
+        raise "OS not in supported list of #{operating_systems.supported_os_names.inspect}"
+      end
+
+      options = parse_command_line
+
+      WifiWand::CommandLineInterface.new(options).call
+    end
+  end
+end

data/lib/wifi-wand/models/base_model.rb

@@ -0,0 +1,250 @@
+require 'json'
+require 'tempfile'
+require_relative '../../wifi-wand'
+
+module WifiWand
+
+class BaseModel
+
+  class OsCommandError < RuntimeError
+    attr_reader :exitstatus, :command, :text
+
+    def initialize(exitstatus, command, text)
+      @exitstatus = exitstatus
+      @command = command
+      @text = text
+    end
+  end
+
+
+  def initialize(verbose = false)
+    @verbose_mode = verbose
+  end
+
+
+  def run_os_command(command)
+    output = `#{command} 2>&1` # join stderr with stdout
+    if $?.exitstatus != 0
+      raise OsCommandError.new($?.exitstatus, command, output)
+    end
+    if @verbose_mode
+      puts "\n\n#{'-' * 79}\nCommand: #{command}\n\nOutput:\n#{output}#{'-' * 79}\n\n"
+    end
+    output
+  end
+
+
+  # This method returns whether or not there is a working Internet connection.
+  # Because of a Mac issue which causes a request to hang if the network is turned
+  # off during its lifetime, we give it only 5 seconds per try,
+  # and limit the number of tries to 3.
+  #
+  # This implementation will probably strike you as overly complex. The following
+  # code looks like it is all that should be necessary, but unfortunately
+  # this implementation often hangs when wifi is turned off while curl is active
+  #
+  # def connected_to_internet?
+  #   script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $?"
+  #   result = `#{script}`.chomp
+  #   puts result
+  #   result == '0'
+  # end
+
+  # TODO Investigate using Curl options: --connect-timeout 1 --max-time 2 --retry 0
+  # to greatly simplify this method.
+  def connected_to_internet?
+
+    tempfile = Tempfile.open('wifi-wand-')
+
+    begin
+      start_status_script = -> do
+        script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $? > #{tempfile.path} &"
+        pid = Process.spawn(script)
+        Process.detach(pid)
+        pid
+      end
+
+      process_is_running = ->(pid) do
+        script = %Q{ps -p #{pid} > /dev/null; echo $?}
+        output = `#{script}`.chomp
+        output == "0"
+      end
+
+      get_connected_state_from_curl = -> do
+        tempfile.close
+        File.read(tempfile.path).chomp == '0'
+      end
+
+      # Do one run, iterating during the timeout period to see if the command has completed
+      do_one_run = -> do
+        end_time = Time.now + 3
+        pid = start_status_script.()
+        while Time.now < end_time
+          if process_is_running.(pid)
+            sleep 0.5
+          else
+            return get_connected_state_from_curl.()
+          end
+        end
+        Process.kill('KILL', pid) if process_is_running.(pid)
+        :hung
+      end
+
+      3.times do
+        connected = do_one_run.()
+        return connected if connected != :hung
+      end
+
+      raise "Could not determine Internet status."
+
+    ensure
+      tempfile.unlink
+    end
+
+  end
+
+
+  # Turns wifi off and then on, reconnecting to the originally connecting network.
+  def cycle_network
+    # TODO: Make this network name saving and restoring conditional on it not having a password.
+    # If the disabled code below is enabled, an error will be raised if a password is required,
+    # even though it is stored.
+    # network_name = current_network
+    wifi_off
+    wifi_on
+    # connect(network_name) if network_name
+  end
+
+
+  def connected_to?(network_name)
+    network_name == connected_network_name
+  end
+
+
+  # Connects to the passed network name, optionally with password.
+  # Turns wifi on first, in case it was turned off.
+  # Relies on subclass implementation of os_level_connect().
+  def connect(network_name, password = nil)
+    # Allow symbols and anything responding to to_s for user convenience
+    network_name = network_name.to_s if network_name
+    password     = password.to_s     if password
+
+    if network_name.nil? || network_name.empty?
+      raise "A network name is required but was not provided."
+    end
+    wifi_on
+    os_level_connect(network_name, password)
+
+    # Verify that the network is now connected:
+    actual_network_name = connected_network_name
+    unless actual_network_name == network_name
+      message = %Q{Expected to connect to "#{network_name}" but }
+      if actual_network_name
+        message << %Q{connected to "#{connected_network_name}" instead.}
+      else
+        message << "unable to connect to any network. Did you "
+      end
+      message << (password ? "provide the correct password?" : "need to provide a password?")
+      raise message
+    end
+    nil
+  end
+
+
+  # Removes the specified network(s) from the preferred network list.
+  # @param network_names names of networks to remove; may be empty or contain nonexistent networks
+  # @return names of the networks that were removed (excludes non-preexisting networks)
+  def remove_preferred_networks(*network_names)
+    networks_to_remove = network_names & preferred_networks # exclude any nonexistent networks
+    networks_to_remove.each { |name| remove_preferred_network(name) }
+  end
+
+
+  def preferred_network_password(preferred_network_name)
+    preferred_network_name = preferred_network_name.to_s
+    if preferred_networks.include?(preferred_network_name)
+      os_level_preferred_network_password(preferred_network_name)
+    else
+      raise "Network #{preferred_network_name} not in preferred networks list."
+    end
+  end
+
+
+  # Waits for the Internet connection to be in the desired state.
+  # @param target_status must be in [:conn, :disc, :off, :on]; waits for that state
+  # @param wait_interval_in_secs sleeps this interval between retries; if nil or absent,
+  #        a default will be provided
+  #
+  def till(target_status, wait_interval_in_secs = nil)
+
+    # One might ask, why not just put the 0.5 up there as the default argument.
+    # We could do that, but we'd still need the line below in case nil
+    # was explicitly specified. The default argument of nil above emphasizes that
+    # the absence of an argument and a specification of nil will behave identically.
+    wait_interval_in_secs ||= 0.5
+
+    finished_predicates = {
+        conn: -> { connected_to_internet? },
+        disc: -> { ! connected_to_internet? },
+        on:   -> { wifi_on? },
+        off:  -> { ! wifi_on? }
+    }
+
+    finished_predicate = finished_predicates[target_status]
+
+    if finished_predicate.nil?
+      raise ArgumentError.new(
+          "Option must be one of #{finished_predicates.keys.inspect}. Was: #{target_status.inspect}")
+    end
+
+    loop do
+      return if finished_predicate.()
+      sleep(wait_interval_in_secs)
+    end
+  end
+
+
+  # Tries an OS command until the stop condition is true.
+  # @command the command to run in the OS
+  # @stop_condition a lambda taking the commands stdout as its sole parameter
+  # @return the stdout produced by the command
+  def try_os_command_until(command, stop_condition, max_tries = 100)
+    max_tries.times do
+      stdout = run_os_command(command)
+      if stop_condition.(stdout)
+        return stdout
+      end
+    end
+    nil
+  end
+
+
+  # Reaches out to ipinfo.io to get public IP address information
+  # in the form of a hash.
+  # You may need to enclose this call in a begin/rescue.
+  def public_ip_address_info
+    JSON.parse(`curl -s ipinfo.io`)
+  end
+
+
+  # @return array of nameserver IP addresses from /etc/resolv.conf, or nil if not found
+  # Though this is strictly *not* OS-agnostic, it will be used by most OS's,
+  # and can be overridden by subclasses (e.g. Windows).
+  def nameservers_using_resolv_conf
+    begin
+      File.readlines('/etc/resolv.conf').grep(/^nameserver /).map { |line| line.split.last }
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+
+
+  def nameservers_using_scutil
+    output = run_os_command('scutil --dns')
+    nameserver_lines_scoped_and_unscoped = output.split("\n").grep(/^\s*nameserver\[/)
+    unique_nameserver_lines = nameserver_lines_scoped_and_unscoped.uniq # take the union
+    nameservers = unique_nameserver_lines.map { |line| line.split(' : ').last.strip }
+    nameservers
+  end
+end
+end

data/lib/wifi-wand/models/mac_os_model.rb

@@ -0,0 +1,299 @@
+require 'shellwords'
+
+require_relative 'base_model'
+
+module WifiWand
+
+class MacOsModel < BaseModel
+
+  AIRPORT_CMD = '/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'
+
+  def initialize(verbose = false)
+    super
+  end
+
+
+  # Identifies the (first) wireless network hardware port in the system, e.g. en0 or en1
+  def wifi_hardware_port
+    @wifi_hardware_port ||= begin
+      lines = run_os_command("networksetup -listallhardwareports").split("\n")
+      # Produces something like this:
+      # Hardware Port: Wi-Fi
+      # Device: en0
+      # Ethernet Address: ac:bc:32:b9:a9:9d
+      #
+      # Hardware Port: Bluetooth PAN
+      # Device: en3
+      # Ethernet Address: ac:bc:32:b9:a9:9e
+      wifi_port_line_num = (0...lines.size).detect do |index|
+        /: Wi-Fi$/.match(lines[index])
+      end
+      if wifi_port_line_num.nil?
+        raise %Q{Wifi port (e.g. "en0") not found in output of: networksetup -listallhardwareports}
+      else
+        lines[wifi_port_line_num + 1].split(': ').last
+      end
+    end
+  end
+
+
+  # Returns data pertaining to available wireless networks.
+  # For some reason, this often returns no results, so I've put the operation in a loop.
+  # I was unable to detect a sort strategy in the airport utility's output, so I sort
+  # the lines alphabetically, to show duplicates and for easier lookup.
+  def available_network_info
+    return nil unless wifi_on? # no need to try
+    command = "#{AIRPORT_CMD} -s"
+    max_attempts = 50
+
+
+    reformat_line = ->(line) do
+      ssid = line[0..31].strip
+      "%-32.32s%s" % [ssid, line[32..-1]]
+    end
+
+
+    process_tabular_data = ->(output) do
+      lines = output.split("\n")
+      header_line = lines[0]
+      data_lines = lines[1..-1]
+      data_lines.map! do |line|
+        # Reformat the line so that the name is left instead of right justified
+        reformat_line.(line)
+      end
+      data_lines.sort!
+      [reformat_line.(header_line)] + data_lines
+    end
+
+
+    output = try_os_command_until(command, ->(output) do
+      ! ([nil, ''].include?(output))
+    end)
+
+    if output
+      process_tabular_data.(output)
+    else
+      raise "Unable to get available network information after #{max_attempts} attempts."
+    end
+  end
+
+
+  def parse_network_names(info)
+    if info.nil?
+      nil
+    else
+      info[1..-1] \
+      .map { |line| line[0..32].rstrip } \
+      .uniq \
+      .sort { |s1, s2| s1.casecmp(s2) }
+    end
+  end
+
+
+  # @return an array of unique available network names only, sorted alphabetically
+  # Kludge alert: the tabular data does not differentiate between strings with and without leading whitespace
+  # Therefore, we get the data once in tabular format, and another time in XML format.
+  # The XML element will include any leading whitespace. However, it includes all <string> elements,
+  # many of which are not network names.
+  # As an improved approximation of the correct result, for each network name found in tabular mode,
+  # we look to see if there is a corresponding string element with leading whitespace, and, if so,
+  # replace it.
+  #
+  # This will not behave correctly if a given name has occurrences with different amounts of whitespace,
+  # e.g. ' x' and '     x'.
+  #
+  # The reason we don't use an XML parser to get the exactly correct result is that we don't want
+  # users to need to install any external dependencies in order to run this script.
+  def available_network_names
+
+    # Parses the XML text (using grep, not XML parsing) to find
+    # <string> elements, and extracts the network name candidates
+    # containing leading spaces from it.
+    get_leading_space_names = ->(text) do
+      text.split("\n") \
+        .grep(%r{<string>}) \
+        .sort \
+        .uniq \
+        .map { |line| line.gsub("<string>", '').gsub('</string>', '').gsub("\t", '') } \
+        .select { |s| s[0] == ' ' }
+    end
+
+
+    output_is_valid = ->(output) { ! ([nil, ''].include?(output)) }
+    tabular_data = try_os_command_until("#{AIRPORT_CMD} -s", output_is_valid)
+    xml_data     = try_os_command_until("#{AIRPORT_CMD} -s -x", output_is_valid)
+
+    if tabular_data.nil? || xml_data.nil?
+      raise "Unable to get available network information; please try again."
+    end
+
+    tabular_data_lines = tabular_data[1..-1] # omit header line
+    names_no_spaces    = parse_network_names(tabular_data_lines.split("\n")).map(&:strip)
+    names_maybe_spaces =  get_leading_space_names.(xml_data)
+
+    names = names_no_spaces.map do |name_no_spaces|
+      match = names_maybe_spaces.detect do |name_maybe_spaces|
+        %r{[ \t]?#{name_no_spaces}$}.match(name_maybe_spaces)
+      end
+
+      match ? match : name_no_spaces
+    end
+
+    names.sort { |s1, s2| s1.casecmp(s2) }    # sort alphabetically, case insensitively
+  end
+
+
+  # Returns data pertaining to "preferred" networks, many/most of which will probably not be available.
+  def preferred_networks
+    lines = run_os_command("networksetup -listpreferredwirelessnetworks #{wifi_hardware_port}").split("\n")
+    # Produces something like this, unsorted, and with leading tabs:
+    # Preferred networks on en0:
+    #         LibraryWiFi
+    #         @thePAD/Magma
+
+    lines.delete_at(0)                         # remove title line
+    lines.map! { |line| line.gsub("\t", '') }  # remove leading tabs
+    lines.sort! { |s1, s2| s1.casecmp(s2) }    # sort alphabetically, case insensitively
+    lines
+  end
+
+
+  # Returns true if wifi is on, else false.
+  def wifi_on?
+    lines = run_os_command("#{AIRPORT_CMD} -I").split("\n")
+    lines.grep("AirPort: Off").none?
+  end
+
+
+  # Turns wifi on.
+  def wifi_on
+    return if wifi_on?
+    run_os_command("networksetup -setairportpower #{wifi_hardware_port} on")
+    wifi_on? ? nil : raise("Wifi could not be enabled.")
+  end
+
+
+  # Turns wifi off.
+  def wifi_off
+    return unless wifi_on?
+    run_os_command("networksetup -setairportpower #{wifi_hardware_port} off")
+    wifi_on? ? raise("Wifi could not be disabled.") : nil
+  end
+
+
+  # This method is called by BaseModel#connect to do the OS-specific connection logic.
+  def os_level_connect(network_name, password = nil)
+    command = "networksetup -setairportnetwork #{wifi_hardware_port} " + "#{Shellwords.shellescape(network_name)}"
+    if password
+      command << ' ' << Shellwords.shellescape(password)
+    end
+    run_os_command(command)
+  end
+
+
+  # @return:
+  #   If the network is in the preferred networks list
+  #     If a password is associated w/this network, return the password
+  #     If not, return nil
+  #   else
+  #     raise an error
+  def os_level_preferred_network_password(preferred_network_name)
+    command = %Q{security find-generic-password -D "AirPort network password" -a "#{preferred_network_name}" -w 2>&1}
+    begin
+      return run_os_command(command).chomp
+    rescue OsCommandError => error
+      if error.exitstatus == 44 # network has no password stored
+        nil
+      else
+        raise
+      end
+    end
+  end
+
+
+  # Returns the IP address assigned to the wifi port, or nil if none.
+  def ip_address
+    begin
+      run_os_command("ipconfig getifaddr #{wifi_hardware_port}").chomp
+    rescue OsCommandError => error
+      if error.exitstatus == 1
+        nil
+      else
+        raise
+      end
+    end
+  end
+
+
+  def remove_preferred_network(network_name)
+    network_name = network_name.to_s
+    run_os_command("sudo networksetup -removepreferredwirelessnetwork " +
+                       "#{wifi_hardware_port} #{Shellwords.shellescape(network_name)}")
+  end
+
+
+  # Returns the network currently connected to, or nil if none.
+  def current_network
+    lines = run_os_command("#{AIRPORT_CMD} -I").split("\n")
+    ssid_lines = lines.grep(/ SSID:/)
+    ssid_lines.empty? ? nil : ssid_lines.first.split('SSID: ').last.strip
+  end
+
+
+  # Disconnects from the currently connected network. Does not turn off wifi.
+  def disconnect
+    run_os_command("sudo #{AIRPORT_CMD} -z")
+    nil
+  end
+
+
+  # Returns some useful wifi-related information.
+  def wifi_info
+
+    info = {
+        'wifi_on'     =>    wifi_on?,
+        'internet_on' => connected_to_internet?,
+        'port'        => wifi_hardware_port,
+        'network'     => current_network,
+        'ip_address'  => ip_address,
+        'nameservers' => nameservers_using_scutil,
+        'timestamp'   => Time.now,
+    }
+    more_output = run_os_command(AIRPORT_CMD + " -I")
+    more_info   = colon_output_to_hash(more_output)
+    info.merge!(more_info)
+    info.delete('AirPort') # will be here if off, but info is already in wifi_on key
+
+    if info['wifi_on']
+      begin
+        info['public_ip'] = public_ip_address_info
+      rescue => e
+        puts "Error obtaining public IP address info, proceeding with everything else:"
+        puts e.to_s
+      end
+    end
+    info
+  end
+
+
+  def open_resource(resource_url)
+    run_os_command('open ' + resource_url)
+  end
+
+
+  # Parses output like the text below into a hash:
+  # SSID: Pattara211
+  # MCS: 5
+  # channel: 7
+  def colon_output_to_hash(output)
+    lines = output.split("\n")
+    lines.each_with_object({}) do |line, new_hash|
+      key, value = line.split(': ')
+      key = key.strip
+      value.strip! if value
+      new_hash[key] = value
+    end
+  end
+  private :colon_output_to_hash
+end
+end