siriproxy 0.4.1

data/lib/siriproxy/command_line.rb

@@ -0,0 +1,201 @@
+require 'optparse'
+require 'yaml'
+require 'ostruct'
+
+# @todo want to make SiriProxy::Commandline without having to
+# require 'siriproxy'. Im sure theres a better way.
+class SiriProxy
+
+end
+
+class SiriProxy::CommandLine
+  BANNER = <<-EOS
+Siri Proxy is a proxy server for Apple's Siri "assistant." The idea is to allow for the creation of custom handlers for different actions. This can allow developers to easily add functionality to Siri.
+
+See: http://github.com/plamoni/SiriProxy/
+
+Usage: siriproxy COMMAND OPTIONS
+
+Commands:
+server            Start up the Siri proxy server
+gencerts          Generate a the certificates needed for SiriProxy
+bundle            Install any dependancies needed by plugins
+console           Launch the plugin test console 
+update [dir]      Updates to the latest code from GitHub or from a provided directory
+help              Show this usage information
+
+Options:
+    Option                           Command    Description
+  EOS
+
+  def initialize
+    @branch = nil
+    parse_options
+    command     = ARGV.shift
+    subcommand  = ARGV.shift
+    case command
+    when 'server'           then run_server(subcommand)
+    when 'gencerts'         then gen_certs
+    when 'bundle'           then run_bundle(subcommand)
+    when 'console'          then run_console
+    when 'update'           then update(subcommand)
+    when 'help'             then usage
+    else                    usage
+    end
+  end
+
+  def run_console
+    load_code
+    $LOG_LEVEL = 0 
+    # this is ugly, but works for now
+    SiriProxy::PluginManager.class_eval do
+      def respond(text, options={})
+        puts "=> #{text}"
+      end
+      def process(text)
+        super(text)
+      end
+      def send_request_complete_to_iphone
+      end
+      def no_matches
+        puts "No plugin responded"
+      end
+    end
+    SiriProxy::Plugin.class_eval do
+      def last_ref_id
+        0
+      end
+      def send_object(object, options={:target => :iphone})
+        puts "=> #{object}"
+      end
+    end
+
+    cora = SiriProxy::PluginManager.new
+    repl = -> prompt { print prompt; cora.process(gets.chomp!) }
+    loop { repl[">> "] }
+  end
+
+  def run_bundle(subcommand='')
+    setup_bundler_path
+    puts `bundle #{subcommand} #{ARGV.join(' ')}`
+  end
+
+  def run_server(subcommand='start')
+    load_code
+    start_server
+    # @todo: support for forking server into bg and start/stop/restart
+    # subcommand ||= 'start'
+    # case subcommand
+    # when 'start'    then start_server
+    # when 'stop'     then stop_server
+    # when 'restart'  then restart_server
+    # end
+  end
+
+  def start_server
+    proxy = SiriProxy.new
+    proxy.start()
+  end
+
+  def gen_certs
+    ca_name = @ca_name ||= ""
+    command = File.join(File.dirname(__FILE__), '..', "..", "scripts", 'gen_certs.sh')
+    sp_root = File.join(File.dirname(__FILE__), '..', "..")
+    puts `#{command} "#{sp_root}" "#{ca_name}"`
+  end
+
+  def update(directory=nil)
+    if(directory)
+      puts "=== Installing from '#{directory}' ==="
+      puts `cd #{directory} && rake install`
+      puts "=== Bundling ===" if $?.exitstatus == 0
+      puts `siriproxy bundle` if $?.exitstatus == 0
+      puts "=== SUCCESS ===" if $?.exitstatus == 0
+      
+      exit $?.exitstatus
+    else
+      branch_opt = @branch ? "-b #{@branch}" : ""
+      @branch = "master" if @branch == nil
+      puts "=== Installing latest code from git://github.com/plamoni/SiriProxy.git [#{@branch}] ==="
+
+	  tmp_dir = "/tmp/SiriProxy.install." + (rand 9999).to_s.rjust(4, "0")
+
+	  `mkdir -p #{tmp_dir}`
+      puts `git clone #{branch_opt} git://github.com/plamoni/SiriProxy.git #{tmp_dir}`  if $?.exitstatus == 0
+      puts "=== Performing Rake Install ===" if $?.exitstatus == 0
+      puts `cd #{tmp_dir} && rake install`  if $?.exitstatus == 0
+      puts "=== Bundling ===" if $?.exitstatus == 0
+      puts `siriproxy bundle`  if $?.exitstatus == 0
+      puts "=== Cleaning Up ===" and puts `rm -rf #{tmp_dir}` if $?.exitstatus == 0
+      puts "=== SUCCESS ===" if $?.exitstatus == 0
+
+      exit $?.exitstatus
+    end 
+  end
+
+  def usage
+    puts "\n#{@option_parser}\n"
+  end
+
+  private
+  
+  def parse_options
+    $APP_CONFIG = OpenStruct.new(YAML.load_file(File.expand_path('~/.siriproxy/config.yml')))
+
+    # Google Public DNS servers
+    $APP_CONFIG.upstream_dns ||= %w[8.8.8.8 8.8.4.4]
+
+    @branch = nil
+    @option_parser = OptionParser.new do |opts|
+      opts.on('-L', '--listen ADDRESS',     '[server]   address to listen on (central or node)') do |listen|
+        $APP_CONFIG.listen = listen
+      end
+      opts.on('-p', '--port PORT',     '[server]   port number for server (central or node)') do |port_num|
+        $APP_CONFIG.port = port_num
+      end
+      opts.on('-l', '--log LOG_LEVEL', '[server]   The level of debug information displayed (higher is more)') do |log_level|
+        $APP_CONFIG.log_level = log_level
+      end
+      opts.on(      '--upstream-dns SERVERS', Array, '[server]   List of upstream DNS servers to query for the real guzzoni.apple.com.  Defaults to Google DNS servers') do |servers|
+        $APP_CONFIG.upstream_dns = servers
+      end
+      opts.on('-u', '--user USER',     '[server]   The user to run as after launch') do |user|
+        $APP_CONFIG.user = user
+      end
+      opts.on('-b', '--branch BRANCH', '[update]   Choose the branch to update from (default: master)') do |branch|
+        @branch = branch
+      end
+      opts.on('-n', '--name CA_NAME',  '[gencerts] Define a common name for the CA (default: "SiriProxyCA")') do |ca_name|
+        @ca_name = ca_name
+      end 
+      opts.on_tail('-v', '--version',  '           show version') do
+        require "siriproxy/version"
+        puts "SiriProxy version #{SiriProxy::VERSION}"
+        exit
+      end
+    end
+    @option_parser.banner = BANNER
+    @option_parser.parse!(ARGV)
+  end
+
+  def setup_bundler_path
+    require 'pathname'
+    ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../../Gemfile",
+      Pathname.new(__FILE__).realpath)
+  end
+
+  def load_code
+    setup_bundler_path
+
+    require 'bundler'
+    require 'bundler/setup'
+
+    require 'siriproxy'
+    require 'siriproxy/connection'
+    require 'siriproxy/connection/iphone'
+    require 'siriproxy/connection/guzzoni'
+
+    require 'siriproxy/plugin'
+    require 'siriproxy/plugin_manager'
+  end
+end

data/lib/siriproxy/connection/guzzoni.rb

@@ -0,0 +1,24 @@
+#####
+# This is the connection to the Guzzoni (the Siri server backend)
+#####
+class SiriProxy::Connection::Guzzoni < SiriProxy::Connection
+  def initialize
+    super
+    self.name = "Guzzoni"
+  end
+  
+  def connection_completed
+    super
+    start_tls(:verify_peer => false)
+  end
+  
+  def received_object(object)		
+    return plugin_manager.process_filters(object, :from_guzzoni)
+
+    #plugin_manager.object_from_guzzoni(object, self)
+  end
+	
+  def block_rest_of_session 
+    @block_rest_of_session = true
+  end
+end

data/lib/siriproxy/connection/iphone.rb

@@ -0,0 +1,50 @@
+require 'resolv'
+
+#####
+  # This is the connection to the iPhone
+#####
+class SiriProxy::Connection::Iphone < SiriProxy::Connection
+  def initialize upstream_dns
+    puts "Create server for iPhone connection"
+    super()
+    self.name = "iPhone"
+    @upstream_dns = upstream_dns
+  end
+
+  def post_init
+    super
+    start_tls(:cert_chain_file  => File.expand_path("~/.siriproxy/server.passless.crt"),
+              :private_key_file => File.expand_path("~/.siriproxy/server.passless.key"),
+              :verify_peer      => false)
+  end
+
+  # Resolves guzzoni.apple.com using the Google DNS servers.  This allows the
+  # machine running siriproxy to use the DNS server returning fake records for
+  # guzzoni.apple.com.
+
+  def resolve_guzzoni
+    addresses = Resolv::DNS.open(nameserver: @upstream_dns) do |dns|
+      res = dns.getresources('guzzoni.apple.com', Resolv::DNS::Resource::IN::A)
+    
+      res.map { |r| r.address }
+    end
+    
+    addresses.map do |address|
+      address.address.unpack('C*').join('.')
+    end.sample
+  end
+
+  def ssl_handshake_completed
+    super
+    self.other_connection = EventMachine.connect(resolve_guzzoni, 443, SiriProxy::Connection::Guzzoni)
+    self.plugin_manager.guzzoni_conn = self.other_connection
+    other_connection.other_connection = self #hehe
+    other_connection.plugin_manager = plugin_manager
+  end
+  
+  def received_object(object)
+    return plugin_manager.process_filters(object, :from_iphone)
+
+    #plugin_manager.object_from_client(object, self)
+  end
+end

data/lib/siriproxy/connection.rb

@@ -0,0 +1,212 @@
+require 'cfpropertylist'
+require 'siriproxy/interpret_siri'
+
+class SiriProxy::Connection < EventMachine::Connection
+  include EventMachine::Protocols::LineText2
+  
+  attr_accessor :other_connection, :name, :ssled, :output_buffer, :input_buffer, :processed_headers, :unzip_stream, :zip_stream, :consumed_ace, :unzipped_input, :unzipped_output, :last_ref_id, :plugin_manager
+
+  def last_ref_id=(ref_id)
+    @last_ref_id = ref_id
+    self.other_connection.last_ref_id = ref_id if other_connection.last_ref_id != ref_id
+  end
+  
+  def initialize
+    super
+    self.processed_headers = false
+    self.output_buffer = ""
+    self.input_buffer = ""
+    self.unzipped_input = ""
+    self.unzipped_output = ""
+    self.unzip_stream = Zlib::Inflate.new
+    self.zip_stream = Zlib::Deflate.new
+    self.consumed_ace = false
+  end
+
+  def post_init
+    self.ssled = false
+  end
+
+  def ssl_handshake_completed
+    self.ssled = true
+    
+    puts "[Info - #{self.name}] SSL completed for #{self.name}" if $LOG_LEVEL > 1
+  end
+  
+  def receive_line(line) #Process header
+    puts "[Header - #{self.name}] #{line}" if $LOG_LEVEL > 2
+    if(line == "") #empty line indicates end of headers
+      puts "[Debug - #{self.name}] Found end of headers" if $LOG_LEVEL > 3
+      set_binary_mode
+      self.processed_headers = true
+    end  
+    self.output_buffer << (line + "\x0d\x0a") #Restore the CR-LF to the end of the line
+    
+    flush_output_buffer()
+  end
+
+  def receive_binary_data(data)
+    self.input_buffer << data
+    
+    ##Consume the "0xAACCEE02" data at the start of the stream if necessary (by forwarding it to the output buffer)
+    if(self.consumed_ace == false)
+      self.output_buffer << input_buffer[0..3]
+      self.input_buffer = input_buffer[4..-1]
+      self.consumed_ace = true;
+    end
+    
+    process_compressed_data()
+    
+    flush_output_buffer()
+  end
+  
+  def flush_output_buffer
+    return if output_buffer.empty?
+  
+    if other_connection.ssled
+      puts "[Debug - #{self.name}] Forwarding #{self.output_buffer.length} bytes of data to #{other_connection.name}" if $LOG_LEVEL > 5
+      #puts  self.output_buffer.to_hex if $LOG_LEVEL > 5
+      other_connection.send_data(output_buffer)
+      self.output_buffer = ""
+    else
+      puts "[Debug - #{self.name}] Buffering some data for later (#{self.output_buffer.length} bytes buffered)" if $LOG_LEVEL > 5
+      #puts  self.output_buffer.to_hex if $LOG_LEVEL > 5
+    end
+  end
+
+  def process_compressed_data    
+    self.unzipped_input << unzip_stream.inflate(self.input_buffer)
+    self.input_buffer = ""
+    puts "========UNZIPPED DATA (from #{self.name} =========" if $LOG_LEVEL > 5
+    puts unzipped_input.to_hex if $LOG_LEVEL > 5
+    puts "==================================================" if $LOG_LEVEL > 5
+    
+    while(self.has_next_object?)
+      object = read_next_object_from_unzipped()
+      
+      if(object != nil) #will be nil if the next object is a ping/pong
+        new_object = prep_received_object(object) #give the world a chance to mess with folks
+    
+        inject_object_to_output_stream(new_object) if new_object != nil #might be nil if "the world" decides to rid us of the object
+      end
+    end
+  end
+
+  def has_next_object?
+    return false if unzipped_input.empty? #empty
+    unpacked = unzipped_input[0...5].unpack('H*').first
+    return true if(unpacked.match(/^0[34]/)) #Ping or pong
+    return true if(unpacked.match(/^ff/)) #clear context
+ 
+    if unpacked.match(/^[0-9][15-9]/)
+      puts "ROGUE PACKET!!! WHAT IS IT?! TELL US!!! IN IRC!! COPY THE STUFF FROM BELOW"
+      puts unpacked.to_hex
+    end 
+
+    objectLength = unpacked.match(/^0200(.{6})/)[1].to_i(16)
+    return ((objectLength + 5) < unzipped_input.length) #determine if the length of the next object (plus its prefix) is less than the input buffer
+  end
+
+  def read_next_object_from_unzipped
+    unpacked = unzipped_input[0...5].unpack('H*').first
+    info = unpacked.match(/^(..)(.{8})$/)
+    
+    if(info[1] == "03" || info[1] == "04" || info[1] == "ff") #Ping or pong -- just get these out of the way (and log them for good measure)
+      object = unzipped_input[0...5]
+      self.unzipped_output << object
+      
+      type = (info[1] == "03") ? "Ping" : ((info[1] == "04") ? "Pong" : "Clear Context")   
+      puts "[#{type} - #{self.name}] (#{info[2].to_i(16)})" if $LOG_LEVEL > 3
+      self.unzipped_input = unzipped_input[5..-1]
+      
+      flush_unzipped_output()
+      return nil
+    end
+  
+    object_size = info[2].to_i(16)
+    prefix = unzipped_input[0...5]
+    object_data = unzipped_input[5...object_size+5]
+    self.unzipped_input = unzipped_input[object_size+5..-1]
+
+    parse_object(object_data)
+  end
+  
+  
+  def parse_object(object_data)
+    plist = CFPropertyList::List.new(:data => object_data)    
+    object = CFPropertyList.native_types(plist.value)
+    
+    object
+  end
+  
+  def inject_object_to_output_stream(object)
+    if object["refId"] != nil && !object["refId"].empty?
+      @block_rest_of_session = false if @block_rest_of_session && self.last_ref_id != object["refId"] #new session
+      self.last_ref_id = object["refId"] 
+    end
+    
+    puts "[Info - Forwarding object to #{self.other_connection.name}] #{object["class"]}" if $LOG_LEVEL > 1
+    
+    object_data = object.to_plist(:plist_format => CFPropertyList::List::FORMAT_BINARY)
+
+    #Recalculate the size in case the object gets modified. If new size is 0, then remove the object from the stream entirely
+    obj_len = object_data.length
+    
+    if(obj_len > 0)
+      prefix = [(0x0200000000 + obj_len).to_s(16).rjust(10, '0')].pack('H*')
+      self.unzipped_output << prefix + object_data
+    end
+    
+    flush_unzipped_output()
+  end
+  
+  def flush_unzipped_output
+    self.zip_stream << self.unzipped_output
+    self.unzipped_output = ""
+    self.output_buffer << zip_stream.flush
+    
+    flush_output_buffer()
+  end
+  
+  def prep_received_object(object)
+    if object["refId"] == self.last_ref_id && @block_rest_of_session
+      puts "[Info - Dropping Object from Guzzoni] #{object["class"]}" if $LOG_LEVEL > 1
+      pp object if $LOG_LEVEL > 3
+      return nil
+    end
+  
+    puts "[Info - #{self.name}] Received Object: #{object["class"]}" if $LOG_LEVEL == 1
+    puts "[Info - #{self.name}] Received Object: #{object["class"]} (group: #{object["group"]})" if $LOG_LEVEL == 2
+    puts "[Info - #{self.name}] Received Object: #{object["class"]} (group: #{object["group"]}, ref_id: #{object["refId"]}, ace_id: #{object["aceId"]})" if $LOG_LEVEL > 2
+    pp object if $LOG_LEVEL > 3
+    
+    #keeping this for filters
+    new_obj = received_object(object)
+    if new_obj == nil 
+      puts "[Info - Dropping Object from #{self.name}] #{object["class"]}" if $LOG_LEVEL > 1
+      pp object if $LOG_LEVEL > 3
+      return nil
+    end
+
+    #block the rest of the session if a plugin claims ownership
+    speech = SiriProxy::Interpret.speech_recognized(object)
+    if speech != nil
+      inject_object_to_output_stream(object)
+      block_rest_of_session if plugin_manager.process(speech) 
+      return nil
+    end
+    
+    
+    #object = new_obj if ((new_obj = SiriProxy::Interpret.unknown_intent(object, self, plugin_manager.method(:unknown_command))) != false)    
+    #object = new_obj if ((new_obj = SiriProxy::Interpret.speech_recognized(object, self, plugin_manager.method(:speech_recognized))) != false)
+    
+    object
+  end  
+  
+  #Stub -- override in subclass
+  def received_object(object)
+    
+    object
+  end 
+
+end

data/lib/siriproxy/interpret_siri.rb

@@ -0,0 +1,50 @@
+######
+# The idea behind this class is that you can call the different
+# methods to get different interpretations of a Siri object.
+# For instance, you can "unknown_intent" and it will check 
+# to see if an object is a "Common#unknownIntent" response and 
+# call the provided processor method with the appropriate info.
+# processor method signatures are provided in comments above each
+# method.
+# 
+# each method will return "nil" if the object is not the valid
+# type. If it is, it will return the result of the processor.
+#####
+class SiriProxy::Interpret
+  class << self
+    #Checks if the object is Guzzoni responding that it can't 
+    #determine the intent of the query
+    #processor(object, connection, unknown_text)
+    def unknown_intent(object, connection, processor) 
+      return false if object == nil
+      return false if (!(object["properties"]["views"][0]["properties"]["dialogIdentifier"] == "Common#unknownIntent") rescue true)
+      
+      searchUtterance =  object["properties"]["views"][1]["properties"]["commands"][0]["properties"]["commands"][0]["properties"]["utterance"]
+      searchText = searchUtterance.split("^")[3]
+      return processor.call(object, connection, searchText)
+      
+      return false
+    end
+    
+    #Checks if the object is Guzzoni responding that it recognized
+    #speech. Sends "best interpretation" phrase to processor
+    #processor(object, connection, phrase)
+    def speech_recognized(object)
+      return nil if object == nil
+      return nil if (!(object["class"] == "SpeechRecognized") rescue true)
+      phrase = ""
+      
+      object["properties"]["recognition"]["properties"]["phrases"].map { |phraseObj| 
+        phraseObj["properties"]["interpretations"].first["properties"]["tokens"].map { |token|
+          tokenProps = token["properties"]
+          
+          phrase = phrase[0..-2] if tokenProps["removeSpaceBefore"] and phrase[-1] == " "
+          phrase << tokenProps["text"]
+          phrase << " " if !tokenProps["removeSpaceAfter"]
+        }
+      }
+      
+      phrase
+    end
+  end
+end

data/lib/siriproxy/plugin.rb

@@ -0,0 +1,58 @@
+require 'cora'
+
+class SiriProxy::Plugin < Cora::Plugin
+  def initialize(config)
+
+  end
+
+  def request_completed
+    self.manager.send_request_complete_to_iphone
+  end
+
+  #use send_object(object, target: :guzzoni) to send to guzzoni
+  def send_object(object, options={})
+    (object = object.to_hash) rescue nil #convert SiriObjects to a hash
+    options[:target] = options[:target] ||= :iphone
+
+    if(options[:target] == :iphone)
+      self.manager.guzzoni_conn.inject_object_to_output_stream(object)
+  	elsif(options[:target] == :guzzoni)
+  	  self.manager.iphone_conn.inject_object_to_output_stream(object)
+  	end
+  end
+
+  def last_ref_id
+    self.manager.iphone_conn.last_ref_id
+  end
+
+  #direction should be :from_iphone, or :from_guzzoni
+  def process_filters(object, direction)
+    return nil if object == nil
+    f = filters[object["class"]]
+    if(f != nil && (f[:direction] == :both || f[:direction] == direction))
+      object = instance_exec(object, &f[:block])
+    end
+
+    object
+  end
+
+  class << self
+    def filter(class_names, options={}, &block)
+      [class_names].flatten.each do |class_name|
+        filters[class_name] = {
+          direction: (options[:direction] ||= :both),
+          block: block
+        }
+      end
+    end
+
+    def filters
+      @filters ||= {}
+    end
+  end
+
+  def filters
+    self.class.filters
+  end
+
+end

data/lib/siriproxy/plugin_manager.rb

@@ -0,0 +1,78 @@
+require 'cora'
+require 'pp'
+
+class SiriProxy::PluginManager < Cora
+  attr_accessor :plugins, :iphone_conn, :guzzoni_conn
+
+  def initialize()
+    load_plugins()
+  end
+
+  def load_plugins()
+    @plugins = []
+    if $APP_CONFIG.plugins
+      $APP_CONFIG.plugins.each do |pluginConfig|
+          if pluginConfig.is_a? String
+            className = pluginConfig
+            requireName = "siriproxy-#{className.downcase}"
+          else
+            className = pluginConfig['name']
+            requireName = pluginConfig['require'] || "siriproxy-#{className.downcase}"
+          end
+          require requireName
+          plugin = SiriProxy::Plugin.const_get(className).new(pluginConfig)
+          plugin.manager = self
+          @plugins << plugin
+      end
+    end
+    log "Plugins loaded: #{@plugins}"
+  end
+
+  def process_filters(object, direction)
+    object_class = object.class #This way, if we change the object class we won't need to modify this code.
+
+    if object['class'] == 'SetRequestOrigin'
+      properties = object['properties']
+      set_location(properties['latitude'], properties['longitude'], properties)
+    end
+
+    plugins.each do |plugin|
+      #log "Processing filters on #{plugin} for '#{object["class"]}'"
+      new_obj = plugin.process_filters(object, direction)
+      object = new_obj if(new_obj == false || new_obj.class == object_class) #prevent accidental poorly formed returns
+      return nil if object == false #if any filter returns "false," then the object should be dropped
+    end
+
+    return object
+  end
+
+  def process(text)
+    begin
+      result = super(text)
+      self.guzzoni_conn.block_rest_of_session if result
+      return result
+    rescue Exception=>e
+      log "Plugin Crashed: #{e}"
+      respond e.to_s, spoken: "a plugin crashed"
+      return true
+    end  
+  end
+
+  def send_request_complete_to_iphone
+    log "Sending Request Completed"
+    object = generate_request_completed(self.guzzoni_conn.last_ref_id)
+    self.guzzoni_conn.inject_object_to_output_stream(object)
+  end
+
+  def respond(text, options={})
+    self.guzzoni_conn.inject_object_to_output_stream(generate_siri_utterance(self.guzzoni_conn.last_ref_id, text, (options[:spoken] or text), options[:prompt_for_response] == true))
+  end
+
+  def no_matches
+    return false
+  end
+
+  def log(text)
+    puts "[Info - Plugin Manager] #{text}" if $LOG_LEVEL >= 1
+  end
+end

data/lib/siriproxy/version.rb

@@ -0,0 +1,3 @@
+class SiriProxy
+  VERSION = "0.4.1"
+end