dacpclient 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 851490abf8148566e8348090625db3b72d2d6328
+  data.tar.gz: c845ff13c853f52927eea02ead5465469a461f1e
+SHA512:
+  metadata.gz: 528948172ba3b6bd76e0cb3cc4ccf15508df58a86267035e65a07b2e489fa53cbcfe57cc868f4641bb18d3921878a04edb61b523f1fc9b01761cca563cc0320b
+  data.tar.gz: 1530e1c99b1d139467fd9638c617fa1fd95f4793abff03a89cad81a07052fa014a7ced470df0a12328663e3d5fd2d96aacbeaedf71123a75fabaa7a1d41a71f9

data/.rubocop.yml

@@ -0,0 +1,5 @@
+# Avoid methods longer than 10 lines of code
+MethodLength:
+  Enabled: false
+LineLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,14 @@
+ruby '2.0.0'
+gemspec
+
+source 'https://rubygems.org'
+
+group :test do
+  gem 'pry'
+  gem 'minitest', '~> 5.0.6'
+  #gem 'coveralls', require: false
+  gem 'rake'
+  gem 'rubocop', github: 'bbatsov/rubocop', ref: '68b73d5c38a' #'~> 0.12.0'
+  gem 'simplecov', require: false
+  #gem 'simple_mock'
+end

data/Gemfile.lock

@@ -0,0 +1,59 @@
+GIT
+  remote: git://github.com/bbatsov/rubocop.git
+  revision: 68b73d5c38ad86f8702302d440437dbd77f677c0
+  ref: 68b73d5c38a
+  specs:
+    rubocop (0.11.0)
+      backports (~> 3.3.3)
+      parser (~> 2.0.0.pre6)
+      powerpack (= 0.0.1)
+      rainbow (>= 1.1.4)
+
+PATH
+  remote: .
+  specs:
+    dacpclient (0.1.0)
+      dnssd (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (1.1.0)
+    backports (3.3.3)
+    coderay (1.0.9)
+    dnssd (2.0)
+    github-markup (0.7.5)
+    method_source (0.8.2)
+    minitest (5.0.6)
+    multi_json (1.7.8)
+    parser (2.0.0.pre6)
+      ast (~> 1.1)
+      slop (~> 3.4, >= 3.4.5)
+    powerpack (0.0.1)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rainbow (1.1.4)
+    rake (10.1.0)
+    redcarpet (3.0.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.6)
+    yard (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dacpclient!
+  github-markup
+  minitest (~> 5.0.6)
+  pry
+  rake
+  redcarpet
+  rubocop!
+  simplecov
+  yard

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011-2013, Jurriaan Pruis <email@jurriaanpruis.nl>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Jurriaan Pruis BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,3 @@
+A DACP (iTunes Remote protocol) client written in the wonderful Ruby language
+
+Look at the remoteclient.rb file for an example client.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop'
+require 'yard'
+YARD::Rake::YardocTask.new
+
+# Rake::TestTask.new do |t|
+#   t.libs << 'lib/docparser'
+#   t.test_files = FileList['test/lib/**/*_test.rb']
+#   t.verbose = true
+# end
+
+task test: :rubocop
+
+task :rubocop do
+  puts "Running Rubocop #{Rubocop::Version::STRING}"
+  args = FileList['**/*.rb', 'Rakefile', 'dacpclient.gemspec']
+  cli = Rubocop::CLI.new
+  fail unless cli.run(args) == 0
+end
+
+task default: :test

data/TODO

@@ -0,0 +1,3 @@
+- Add tests (DMAPBuilder)
+- Add more tagdefinitions
+- Documentation :)

data/dacpclient.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dacpclient/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dacpclient'
+  spec.version       = DACPClient::VERSION
+  spec.authors       = ['Jurriaan Pruis']
+  spec.email         = ['email@jurriaanpruis.nl']
+  spec.description   = 'A DACP (iTunes Remote protocol) client written in the wonderful Ruby language'
+  spec.summary       = 'A DACP (iTunes Remote protocol) client written in the wonderful Ruby language'
+  spec.homepage      = 'https://github.com/jurriaan/ruby-dacpclient'
+  spec.license       = 'MIT'
+  spec.platform      = Gem::Platform::RUBY
+
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+  spec.extra_rdoc_files = ['README.md', 'LICENSE']
+
+  spec.add_runtime_dependency 'dnssd', '~> 2.0'
+
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'github-markup'
+  spec.required_ruby_version = '>= 2.0.0'
+end

data/lib/dacpclient/client.rb

@@ -0,0 +1,196 @@
+$LOAD_PATH.unshift __dir__
+require 'rubygems'
+require 'bundler/setup'
+require 'digest'
+require 'net/http'
+require_relative 'pairingserver'
+require_relative 'dmapparser'
+require_relative 'dmapbuilder'
+require 'uri'
+require 'cgi'
+
+module DACPClient
+  class Client
+
+    def initialize(name, host = 'localhost', port = 3689)
+      @client = Net::HTTP.new(host, port)
+      @name = name
+      @host = host
+      @port = port
+      @service = nil
+      @session_id = nil
+      @mediarevision = 1
+    end
+
+    def pair(pin = nil)
+      pairingserver = PairingServer.new(@name, '0.0.0.0', 1024)
+      pairingserver.pin = pin unless pin.nil?
+      pairingserver.start
+    end
+
+    def self.get_guid(name)
+       d = Digest::SHA2.hexdigest(name)
+       d[0..15]
+    end
+
+    def serverinfo
+      do_action('server-info')
+    end
+
+    def login(pin = nil)
+      response = do_action(:login, { 'pairing-guid' => '0x' + Client.get_guid(@name) })
+      @session_id = response[:mlid]
+      response
+    rescue DACPForbiddenError => e
+      puts "#{e.result.message} error: Cannot login, starting pairing process"
+      pin = 4.times.map { Random.rand(10) } if pin.nil?
+      pair(pin)
+      retry
+    end
+
+    def content_codes
+      do_action('content-codes', {}, true)
+    end
+
+    def play
+      do_action(:play)
+    end
+
+    def playpause
+      do_action(:playpause)
+    end
+
+    def stop
+      do_action(:stop)
+    end
+
+    def pause
+      do_action(:pause)
+    end
+
+    def seek(ms)
+      do_action(:setproperty, 'dacp.playingtime' => ms)
+    end
+
+    def status(wait = false)
+      revision = wait ? @mediarevision : 1
+      result = do_action(:playstatusupdate, 'revision-number' => revision)
+      @mediarevision = result[:cmsr]
+      result
+    end
+
+    def next
+      do_action(:nextitem)
+    end
+
+    def prev
+      do_action(:previtem)
+    end
+
+    def get_volume
+      response = do_action(:getproperty, properties: 'dmcp.volume')
+      response[:cmvo]
+    end
+
+    def set_volume(volume)
+      do_action(:setproperty, 'dmcp.volume' => volume)
+    end
+
+    def get_repeat
+      response = do_action(:getproperty, properties: 'dacp.repeatstate')
+      response[:carp]
+    end
+
+    def set_repeat(volume)
+      do_action(:setproperty, 'dmcp.volume' => volume)
+    end
+
+    def get_shuffle
+      response = do_action(:getproperty, properties: 'dmcp.shufflestate')
+      response[:cash]
+    end
+
+    def set_shuffle(volume)
+      do_action(:setproperty, 'dmcp.volume' => volume)
+    end
+
+    def ctrl_int
+      do_action('ctrl-int', {}, false)
+    end
+
+    def logout
+      do_action(:logout, {}, false)
+    end
+
+    def queue(id)
+      do_action 'playqueue-edit', { command: 'add', query: "\'dmap.itemid:#{id}\'" }
+    end
+
+    def clear_queue
+      do_action 'playqueue-edit', { command: 'clear' }
+    end
+
+    def list_queue
+      do_action 'playqueue-contents', {}
+    end
+
+    def databases
+      do_action 'databases', {}, true
+    end
+
+    def playlists(db)
+      do_action "databases/#{db}/containers", {}, true
+    end
+
+    def artwork(database, id, width = 320, height = 320)
+      do_action "databases/#{database}/items/#{id}/extra_data/artwork", { mw: width, mh: height }, true
+    end
+
+    def now_playing_artwork(width = 320, height = 320)
+      do_action :nowplayingartwork, { mw: width, mh: height }
+    end
+
+    def search(db, container, search)
+      words = search.split
+      queries = []
+      queries.push(words.map { |v| "\'dmap.itemname:*#{v}*\'" }.join('+'))
+      # queries.push(words.map{|v| "\'daap.songartist:*#{v}*\'"}.join('+'))
+      query = '(' + queries.map { |q| "(#{q})" }.join(',') + ')'
+      do_action "databases/#{db}/containers/#{container}/items", { type: 'music', sort: 'album', meta: 'dmap.itemid,dmap.itemname,daap.songartist,daap.songalbum', query: query }, true
+    end
+
+    private
+
+    def do_action(action, params = {}, cleanurl = false)
+      action = '/' + action.to_s
+      unless @session_id.nil?
+        params['session-id'] = @session_id
+        action = '/ctrl-int/1' + action unless cleanurl
+      end
+      params = params.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join '&'
+      uri = URI::HTTP.build({ host: @host, port: @port, path: action, query: params })
+      req = Net::HTTP::Get.new(uri.request_uri)
+      req.add_field('Viewer-Only-Client', '1')
+      res = Net::HTTP.new(uri.host, uri.port).start { |http| http.request(req) }
+      if res.kind_of?(Net::HTTPServiceUnavailable) || res.kind_of?(Net::HTTPForbidden)
+        raise DACPForbiddenError.new(res)
+      elsif !res.kind_of?(Net::HTTPSuccess)
+        p res
+        return nil
+      end
+
+      if res['Content-Type'] == 'application/x-dmap-tagged'
+        DMAPParser.parse(res.body)
+      else
+        res.body
+      end
+    end
+  end
+
+  class DACPForbiddenError < StandardError
+    attr_reader :result
+    def initialize(res)
+      @result = res
+    end
+  end
+end

data/lib/dacpclient/dmapbuilder.rb

@@ -0,0 +1,36 @@
+module DACPClient
+  class DMAPBuilder
+    attr_reader :result
+
+    def initialize
+      @dmap_stack = []
+    end
+
+    def self.method_missing(method, *args, &block)
+      self.new.send(method, *args, &block)
+    end
+
+    def method_missing(method, *args, &block)
+      return super if method.to_s.length != 4 || (tag = DMAPParser::Types.find { |a| a.tag.to_s == method.to_s }).nil?
+      if block_given?
+        if tag.type == :container
+          @dmap_stack << DMAPParser::TagContainer.new(tag)
+          instance_eval(&block)
+          if @dmap_stack.length > 1
+            @dmap_stack.last.value << @dmap_stack.pop
+          else
+            return @result = @dmap_stack.pop
+          end
+        else
+          raise "Tag #{method} is not a container type"
+        end
+      else
+        if @dmap_stack.length > 0
+          @dmap_stack.last.value << DMAPParser::Tag.new(tag, args.size > 1 ? args : args.first)
+        else
+          raise 'Cannot build DMAP without a valid container'
+        end
+      end
+    end
+  end
+end

data/lib/dacpclient/dmapconverter.rb

@@ -0,0 +1,65 @@
+module DACPClient
+  class DMAPConverter
+    class << self
+      def bin_to_byte(data)
+        data.unpack('C').first
+      end
+
+      def bin_to_long(data)
+        (bin_to_int(data[0..3]) << 32) + bin_to_int(data[4..7])
+      end
+
+      def bin_to_int(data)
+        data.unpack('N').first
+      end
+
+      def bin_to_short(data)
+        data.unpack('n').first
+      end
+
+      def bin_to_bool(data)
+        data == "\x01"
+      end
+
+      def bin_to_version(data)
+        data.unpack('nCC').join '.'
+      end
+
+      def bin_to_hex(data)
+        data.bytes.reduce('') { |a, e| a += sprintf('%02X', e) }
+      end
+
+      def bool_to_bin(data)
+        if data.true?
+          "\x01"
+        else
+          "\x00"
+        end
+      end
+
+      def int_to_bin(data)
+        [data.to_i].pack 'N'
+      end
+
+      def byte_to_bin(data)
+        [data.to_i].pack 'C'
+      end
+
+      def long_to_bin(data)
+        [data >> 32, data & 0xfffffff].pack 'NN'
+      end
+
+      def short_to_bin(data)
+        [data.to_i].pack 'n'
+      end
+
+      def version_to_bin(data)
+        data.split('.').pack 'nCC'
+      end
+
+      def hex_to_bin(data)
+        [data].pack 'H*'
+      end
+    end
+  end
+end

data/lib/dacpclient/dmapparser.rb

@@ -0,0 +1,82 @@
+require_relative 'tagdefinitions'
+require_relative 'dmapconverter'
+
+require 'stringio'
+module DACPClient
+  class DMAPParser
+
+    def self.parse(response)
+      return nil if response.nil? || response.length < 8
+      response = StringIO.new(response)
+      ret = TagContainer.new
+      key = response.read(4)
+      ret.type = Types.find { |a| a.tag == key }
+      response.read(4) # ignore length for now
+      ret.value = parse_container(response)
+      ret
+    end
+
+    private
+
+    def self.parse_container(response)
+      values = []
+
+      until response.eof?
+        key = response.read(4)
+        length = DMAPConverter.bin_to_int(response.read(4))
+        data = response.read(length)
+        tag = Types.find { |a| a.tag.to_s == key }
+        # puts "#{key} (#{length}): #{data.inspect}"
+        p data if !tag.nil? && tag.tag.to_s == 'msas'
+        values << if !tag.nil?
+          case tag.type
+          when :container
+            TagContainer.new(tag, parse_container(StringIO.new(data)))
+          when :byte
+            Tag.new(tag, DMAPConverter.bin_to_byte(data))
+          when :uint16, :short
+            Tag.new(tag, DMAPConverter.bin_to_short(data))
+          when :uint32
+            Tag.new(tag, DMAPConverter.bin_to_int(data))
+          when :uint64
+            Tag.new(tag, DMAPConverter.bin_to_long(data))
+          when :bool
+            Tag.new(tag, DMAPConverter.bin_to_bool(data))
+          when :hex
+            Tag.new(tag, DMAPConverter.bin_to_hex(data))
+          when :string
+            Tag.new(tag, data)
+          when :date
+            Tag.new tag, Time.at(DMAPConverter.bin_to_int(data))
+          when :version
+            Tag.new tag, DMAPConverter.bin_to_version(data)
+          else
+            puts "Unknown type #{tag.type}"
+            Tag.new(tag, parseunknown(data))
+          end
+        else
+          # puts "Unknown key #{key}"
+          Tag.new(TagDefinition.new(key, :unknown, "unknown (#{data.bytesize})"), parseunknown(data))
+        end
+      end
+      values
+    end
+
+    def self.parseunknown(data)
+      if data =~ /[^\x20-\x7e]/
+        if data.bytesize == 1
+          DMAPConverter.bin_to_byte(data)
+        elsif data.bytesize == 4
+          DMAPConverter.bin_to_int(data)
+        elsif data.bytesize == 8
+          DMAPConverter.bin_to_long(data)
+        else
+          data
+        end
+      else
+        data
+      end
+    end
+
+  end
+end

data/lib/dacpclient/pairingserver.rb

@@ -0,0 +1,66 @@
+require 'socket'
+require 'dnssd'
+require 'digest'
+module DACPClient
+  class PairingServer
+    attr_accessor :pin, :device_type
+    def initialize(name, host, port = 1024)
+      @name = name
+      @port = port
+      @host = host
+      @pair = Client.get_guid(@name)
+      @pin = [0, 0, 0, 0]
+      @device_type = 'iPod'
+    end
+
+    def start
+      name = @name
+      pair  = @pair
+      device_type = @device_type
+      puts "Pairing started (pincode=#{@pin.join})"
+      txtrecord = DNSSD::TextRecord.new({
+        'DvNm' => @name,
+        'Revm' => '10000',
+        'DvTy' => @device_type,
+        'RemN' => 'Remote',
+        'txtvers' => '1',
+        'Pair' => @pair
+      })
+
+      pairingstring = DMAPBuilder.cmpa do
+        cmpg pair
+        cmnm name
+        cmty device_type
+      end.to_dmap
+
+      expected = PairingServer.generate_pin_challenge(@pair, @pin)
+      server = TCPServer.open(@host, @port)
+      @service = DNSSD.register!(@name, '_touch-remote._tcp', 'local', @port,  txtrecord)
+
+      while (client = server.accept)
+        get = client.gets
+        code = get.match(/pairingcode=([^&]*)/)[1]
+
+        if code == expected
+          client.print "HTTP/1.1 200 OK\r\nContent-Length: #{pairingstring.length}\r\n\r\n#{pairingstring}"
+          puts 'Pairing succeeded :)'
+          client.close
+          break
+        else
+          puts 'Wrong pincode entered'
+          client.print "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n"
+        end
+        client.close
+      end
+      server.close
+
+      sleep 1 # sleep so iTunes accepts our login
+    end
+
+    def self.generate_pin_challenge(pair, pin)
+      pin_string = pin.map { |i| "#{i}\x00" }.join
+      Digest::MD5.hexdigest(pair + pin_string).upcase
+    end
+
+  end
+end

data/lib/dacpclient/tagdefinitions.rb

@@ -0,0 +1,252 @@
+# encoding: UTF-8
+
+module DACPClient
+  class DMAPParser
+
+    Tag = Struct.new(:type, :value) do
+      def inspect(level = 0)
+        "#{'  ' * level}#{type}: #{value}"
+      end
+
+      def to_dmap
+        value = self.value
+        value = case type.type
+                when :container
+                  value.reduce('') { |a, e| a += e.to_dmap }
+                when :byte
+                  DMAPConverter.byte_to_bin value
+                when :uint16, :short
+                  DMAPConverter.short_to_bin value
+                when :uint32
+                  DMAPConverter.int_to_bin value
+                when :uint64
+                  DMAPConverter.long_to_bin value
+                when :bool
+                  DMAPConverter.bool_to_bin value
+                when :hex
+                  DMAPConverter.hex_to_bin value
+                when :string
+                  value
+                when :date
+                  DMAPConverter.int_to_bin value.to_i
+                when :version
+                  DMAPConverter.version_to_bin value.to_i
+                else
+                  puts "Unknown type #{tag.type}"
+                  # Tag.new tag, parseunknown(data)
+                  value
+                end
+        type.tag.to_s + [value.length].pack('N') + value
+      end
+    end
+
+    class TagContainer < Tag
+
+      def initialize(type = nil, value = [])
+        super type, value
+      end
+
+      def inspect(level = 0)
+        "#{'  ' * level}#{type}:\n" + value.reduce('') { |a, e| a + e.inspect(level + 1).chomp + "\n" }
+      end
+
+      def get_value(key)
+        key = key.to_s
+        val = value.find { |e| e.type.tag == key }
+        val = value.find { |e| e.type.name == key } if val.nil?
+        if val.type.type == :container
+          val
+        else
+          val.value
+        end
+      end
+
+      alias_method :[], :get_value
+
+      def has?(key)
+        key = key.to_s
+        val = value.find { |e| e.type.tag == key }
+        val = value.find { |e| e.type.name == key } if val.nil?
+        !val.nil?
+      end
+
+      def method_missing(method, *arguments, &block)
+        value.each do |dmap|
+          return dmap.value if dmap.type.tag.to_s == method.to_s
+        end
+        super
+      end
+    end
+
+    TagDefinition = Struct.new(:tag, :type, :name) do
+      def inspect
+        "#{tag} (#{name}: #{type})"
+      end
+
+      def to_s
+        "#{tag} (#{name}: #{type})"
+      end
+    end
+
+    # Sources:
+    # https://github.com/chendo/dmap-ng/blob/master/lib/dmap/tag_definitions.rb
+    # https://code.google.com/p/ytrack/wiki/DMAP
+    # https://code.google.com/p/tunesremote-se/wiki/ContentCodes
+    # /content-codes
+    Types = [
+      TagDefinition.new('mcon', :container, 'dmap.container'),
+      TagDefinition.new('msrv', :container, 'dmap.serverinforesponse'),
+      TagDefinition.new('msml', :container, 'dmap.msml'),
+      TagDefinition.new('mccr', :container, 'dmap.contentcodesresponse'),
+      TagDefinition.new('mdcl', :container, 'dmap.dictionary'),
+      TagDefinition.new('mlog', :container, 'dmap.loginresponse'),
+      TagDefinition.new('mupd', :container, 'dmap.updateresponse'),
+      TagDefinition.new('avdb', :container, 'daap.serverdatabases'),
+      TagDefinition.new('mlcl', :container, 'dmap.listing'),
+      TagDefinition.new('mlit', :container, 'dmap.listingitem'),
+      TagDefinition.new('mbcl', :container, 'dmap.bag'),
+      TagDefinition.new('adbs', :container, 'daap.returndatabasesongs'),
+      TagDefinition.new('aply', :container, 'daap.databaseplaylists'),
+      TagDefinition.new('apso', :container, 'daap.playlistsongs'),
+      TagDefinition.new('mudl', :container, 'dmap.deletedidlisting'),
+      TagDefinition.new('abro', :container, 'daap.databasebrowse'),
+      TagDefinition.new('abal', :container, 'daap.browsealbumlisting'),
+      TagDefinition.new('abar', :container, 'daap.browseartistlisting'),
+      TagDefinition.new('abcp', :container, 'daap.browsecomposerlisting'),
+      TagDefinition.new('abgn', :container, 'daap.browsegenrelisting'),
+      TagDefinition.new('prsv', :container, 'daap.resolve'),
+      TagDefinition.new('arif', :container, 'daap.resolveinfo'),
+      TagDefinition.new('casp', :container, 'dacp.speakers'),
+      TagDefinition.new('caci', :container, 'dacp.controlint'),
+      TagDefinition.new('cmpa', :container, 'dacp.pairinganswer'),
+      TagDefinition.new('cacr', :container, 'dacp.cacr'),
+      TagDefinition.new('cmcp', :container, 'dmcp.controlprompt'),
+      TagDefinition.new('cmgt', :container, 'dmcp.getpropertyresponse'),
+      TagDefinition.new('cmst', :container, 'dmcp.status'),
+      TagDefinition.new('agal', :container, 'daap.albumgrouping'),
+      TagDefinition.new('minm', :string, 'dmap.itemname'),
+      TagDefinition.new('msts', :string, 'dmap.statusstring'),
+      TagDefinition.new('mcna', :string, 'dmap.contentcodesname'),
+      TagDefinition.new('asal', :string, 'daap.songalbum'),
+      TagDefinition.new('asaa', :string, 'daap.songalbumartist'),
+      TagDefinition.new('asar', :string, 'daap.songartist'),
+      TagDefinition.new('ascm', :string, 'daap.songcomment'),
+      TagDefinition.new('asfm', :string, 'daap.songformat'),
+      TagDefinition.new('aseq', :string, 'daap.songeqpreset'),
+      TagDefinition.new('asgn', :string, 'daap.songgenre'),
+      TagDefinition.new('asdt', :string, 'daap.songdescription'),
+      TagDefinition.new('asul', :string, 'daap.songdataurl'),
+      TagDefinition.new('ceWM', :string, 'com.apple.itunes.welcome-message'), # not a official name?
+      TagDefinition.new('ascp', :string, 'daap.songcomposer'),
+      TagDefinition.new('assu', :string, 'daap.sortartist'),
+      TagDefinition.new('assa', :string, 'daap.sortalbum'),
+      TagDefinition.new('agrp', :string, 'daap.songgrouping'),
+      TagDefinition.new('cann', :string, 'daap.nowplayingtrack'),
+      TagDefinition.new('cana', :string, 'daap.nowplayingartist'),
+      TagDefinition.new('canl', :string, 'daap.nowplayingalbum'),
+      TagDefinition.new('cang', :string, 'daap.nowplayinggenre'),
+      TagDefinition.new('cmnm', :string, 'dacp.devicename'),
+      TagDefinition.new('cmty', :string, 'dacp.devicetype'),
+      TagDefinition.new('cmpg', :hex, 'dacp.pairingguid'), # hex string
+      TagDefinition.new('mper', :uint64, 'dmap.persistentid'),
+      TagDefinition.new('canp', :uint64, 'dacp.nowplaying'),
+      TagDefinition.new('cmpy', :uint64, 'dacp.passguid'),
+      TagDefinition.new('mstt', :uint32, 'dmap.status'), # http status??
+      TagDefinition.new('mcnm', :uint32, 'dmap.contentcodesnumber'),
+      TagDefinition.new('miid', :uint32, 'dmap.itemid'),
+      TagDefinition.new('mcti', :uint32, 'dmap.containeritemid'),
+      TagDefinition.new('mpco', :uint32, 'dmap.parentcontainerid'),
+      TagDefinition.new('mimc', :uint32, 'dmap.itemcount'),
+      TagDefinition.new('mrco', :uint32, 'dmap.returnedcount'),
+      TagDefinition.new('mtco', :uint32, 'dmap.containercount'),
+      TagDefinition.new('mstm', :uint32, 'dmap.timeoutinterval'),
+      TagDefinition.new('msdc', :uint32, 'dmap.databasescount'),
+      TagDefinition.new('msma', :uint32, 'dmap.speakermachineaddress'),
+      TagDefinition.new('mlid', :uint32, 'dmap.sessionid'),
+      TagDefinition.new('assr', :uint32, 'daap.songsamplerate'),
+      TagDefinition.new('assz', :uint32, 'daap.songsize'),
+      TagDefinition.new('asst', :uint32, 'daap.songstarttime'),
+      TagDefinition.new('assp', :uint32, 'daap.songstoptime'),
+      TagDefinition.new('astm', :uint32, 'daap.songtime'),
+      TagDefinition.new('msto', :uint32, 'dmap.utcoffset'),
+      TagDefinition.new('cmsr', :uint32, 'dmcp.mediarevision'),
+      TagDefinition.new('caas', :uint32, 'dacp.albumshuffle'),
+      TagDefinition.new('caar', :uint32, 'dacp.albumrepeat'),
+      TagDefinition.new('cant', :uint32, 'dacp.remainingtime'),
+      TagDefinition.new('cmmk', :uint32, 'dmcp.mediakind'),
+      TagDefinition.new('cast', :uint32, 'dacp.tracklength'),
+      TagDefinition.new('asai', :uint32, 'daap.songalbumid'),
+      TagDefinition.new('aeNV', :uint32, 'com.apple.itunes.norm-volume'),
+      TagDefinition.new('cmvo', :uint32, 'dmcp.volume'),
+      TagDefinition.new('mcty', :uint16, 'dmap.contentcodestype'),
+      TagDefinition.new('asbt', :uint16, 'daap.songsbeatsperminute'),
+      TagDefinition.new('asbr', :uint16, 'daap.songbitrate'),
+      TagDefinition.new('asdc', :uint16, 'daap.songdisccount'),
+      TagDefinition.new('asdn', :uint16, 'daap.songdiscnumber'),
+      TagDefinition.new('astc', :uint16, 'daap.songtrackcount'),
+      TagDefinition.new('astn', :uint16, 'daap.songtracknumber'),
+      TagDefinition.new('asyr', :uint16, 'daap.songyear'),
+      TagDefinition.new('ated', :uint16, 'daap.supportsextradata'),
+      TagDefinition.new('asgr', :uint16, 'daap.supportsgroups'),
+      TagDefinition.new('mikd', :byte, 'dmap.itemkind'),
+      TagDefinition.new('casu', :byte, 'dacp.su'),
+      TagDefinition.new('msau', :byte, 'dmap.authenticationmethod'),
+      TagDefinition.new('mstu', :byte, 'dmap.updatetype'),
+      TagDefinition.new('asrv', :byte, 'daap.songrelativevolume'),
+      TagDefinition.new('asur', :byte, 'daap.songuserrating'),
+      TagDefinition.new('asdk', :byte, 'daap.songdatakind'),
+      TagDefinition.new('caps', :byte, 'dacp.playstatus'),
+      TagDefinition.new('cash', :byte, 'dacp.shufflestate'),
+      TagDefinition.new('carp', :byte, 'dacp.repeatstate'),
+      TagDefinition.new('muty', :byte, 'dmap.updatetype'),
+      TagDefinition.new("f\215ch", :byte, 'dmap.haschildcontainers'),
+      TagDefinition.new('msas', :byte, 'dmap.authenticationschemes'),
+      TagDefinition.new('cavs', :bool, 'dacp.visualizer'), # Source: https://code.google.com/p/tunesremote-plus/source/browse/trunk/src/org/tunesremote/daap/Status.java
+      TagDefinition.new('cafs', :bool, 'dacp.fullscreen'),
+      TagDefinition.new('ceGS', :bool, 'com.apple.itunes.genius-selectable'),
+      TagDefinition.new('mslr', :bool, 'dmap.loginrequired'),
+      TagDefinition.new('msal', :bool, 'dmap.supportsautologout'),
+      TagDefinition.new('msup', :bool, 'dmap.supportsupdate'),
+      TagDefinition.new('mspi', :bool, 'dmap.supportspersistenids'),
+      TagDefinition.new('msex', :bool, 'dmap.supportsextensions'),
+      TagDefinition.new('msbr', :bool, 'dmap.supportsbrowse'),
+      TagDefinition.new('msqy', :bool, 'dmap.supportsquery'),
+      TagDefinition.new('msix', :bool, 'dmap.supportsindex'),
+      TagDefinition.new('msrs', :bool, 'dmap.supportsresolve'),
+      TagDefinition.new('asco', :bool, 'daap.songcompliation'),
+      TagDefinition.new('asdb', :bool, 'daap.songdisabled'),
+      TagDefinition.new('abpl', :bool, 'daap.baseplaylist'),
+      TagDefinition.new('aeSP', :bool, 'com.apple.itunes.smart-playlist'),
+      TagDefinition.new('aePP', :bool, 'com.apple.itunes.is-podcast-playlist'),
+      TagDefinition.new('aePS', :bool, 'com.apple.itunes.special-playlist'),
+      TagDefinition.new('aeSG', :bool, 'com.apple.itunes.saved-genius'),
+      TagDefinition.new('aeFP', :bool, 'com.apple.itunes.req-fplay'),
+      TagDefinition.new('aeHV', :bool, 'com.apple.itunes.has-video'),
+      TagDefinition.new('caia', :bool, 'dacp.isavailiable'),
+      TagDefinition.new('ceVO', :bool, 'com.apple.itunes.voting-enabled'), # not an official name
+      TagDefinition.new('aeSV', :version, 'com.apple.itunes.music-sharing-version'),
+      TagDefinition.new('mpro', :version, 'dmap.protocolversion'),
+      TagDefinition.new('apro', :version, 'daap.protocolversion'),
+      TagDefinition.new('musr', :version, 'dmap.serverrevision'),
+      TagDefinition.new('mstc', :date, 'dmap.utc-time'),
+      TagDefinition.new('asda', :date, 'daap.songdateadded'),
+      TagDefinition.new('asdm', :date, 'daap.songdatemodified'),
+      TagDefinition.new('ceJC', :bool, 'com.apple.itunes.jukebox-client-vote'),
+      TagDefinition.new('ceJI', :bool, 'com.apple.itunes.jukebox-current'),
+      TagDefinition.new('ceJS', :uint16, 'com.apple.itunes.jukebox-score'),
+      TagDefinition.new('ceJV', :bool, 'com.apple.itunes.jukebox-vote'),
+      TagDefinition.new('ceQR', :container, 'com.apple.itunes.playqueue-contents-response'),
+      TagDefinition.new('ceQS', :container, 'com.apple.itunes.playqueue-contents-???'),
+      TagDefinition.new('ceQs', :uint64, 'com.apple.itunes.playqueue-id'), # non-official name
+      TagDefinition.new('ceQa', :string, 'com.apple.itunes.playqueue-album'),
+      TagDefinition.new('ceQg', :string, 'com.apple.itunes.playqueue-genre'),
+      TagDefinition.new('ceQn', :string, 'com.apple.itunes.playqueue-name'),
+      TagDefinition.new('ceQr', :string, 'com.apple.itunes.playqueue-artist'),
+      TagDefinition.new('msml', :container, 'msml'),
+      TagDefinition.new('aeGs', :bool, 'com.apple.itunes.can-be-genius-seed'),
+      TagDefinition.new('aprm', :short, 'daap.playlistrepeatmode'),
+      TagDefinition.new('apsm', :short, 'daap.playlistshufflemode'),
+
+    ].freeze
+  end
+end

data/lib/dacpclient/version.rb

@@ -0,0 +1,3 @@
+module DACPClient
+  VERSION = '0.1.0'
+end

data/lib/dacpclient.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift __dir__
+require 'dacpclient/client'

data/remoteclient.rb

@@ -0,0 +1,126 @@
+$LOAD_PATH.unshift __dir__
+require File.expand_path('lib/dacpclient.rb', __dir__)
+require 'english'
+require 'socket'
+include DACPClient
+class CLIClient
+  def initialize
+    @client = DACPClient::Client.new("CLIClient (#{Socket.gethostname})", 'localhost', 3689)
+    @login = false
+  end
+
+  def parse_arguments(arguments)
+    if arguments.length > 0 && !([:parse_arguments].include?(arguments.first.to_sym)) && self.class.instance_methods(false).include?(arguments.first.to_sym)
+      method = arguments.first.to_sym
+      send method
+      status unless %i{help usage}.include?(method)
+    else
+      usage
+    end
+  end
+
+  def status
+    login
+    status = @client.status
+    if status.caps == 2
+      puts '[STOPPED]'
+    else
+      name = status.cann
+      artist = status.cana
+      album = status.canl
+      playstatus = status.caps != 4 ? 'paused' : 'playing'
+      remaining = status.cant
+      total = status.cast
+      current = total - remaining
+      puts "[#{playstatus.upcase} (#{format_time(current)}/#{format_time(total)})] #{name} - #{artist} (#{album})"
+    end
+  end
+
+  def play
+    login
+    @client.play
+  end
+
+  def pause
+    login
+    @client.pause
+  end
+
+  def playpause
+    login
+    @client.playpause
+  end
+
+  def next
+    login
+    @client.next
+  end
+
+  def prev
+    login
+    @client.prev
+  end
+
+  def databases
+    login
+    puts @client.databases
+  end
+
+  def playqueue
+    login
+    puts @client.list_queue
+  end
+
+  def upnext
+    login
+    items = @client.list_queue.mlcl.select { |item| item.type.tag == 'mlit' }
+    puts 'Up next:'
+    puts '--------'
+    puts
+    items.each do |item|
+      name = item.ceQn
+      artist = item.ceQr
+      album = item.ceQa
+      puts "#{name} - #{artist} (#{album})"
+    end
+    puts
+  end
+
+  def debug
+    login
+    require 'pry'
+    binding.pry
+  end
+
+  def usage
+    puts "Usage: #{$PROGRAM_NAME} [command]"
+    puts
+    puts 'Where command is one of the following:'
+
+    puts CLIClient.instance_methods(false).reject { |m| [:parse_arguments].include?(m)  }
+  end
+
+  alias_method :previous, :prev
+  alias_method :help, :usage
+
+  private
+
+  def login
+    @client.login unless @login
+    @login = true
+  end
+
+  def format_time(millis)
+    seconds, millis = millis.divmod(1000)
+    minutes, seconds = seconds.divmod(60)
+    hours, minutes = minutes.divmod(60)
+    if hours == 0
+      sprintf('%02d:%02d', minutes, seconds)
+    else
+      sprintf('%02d:%02d:%02d', hours, minutes, seconds)
+    end
+  end
+end
+
+cli = CLIClient.new
+cli.parse_arguments(Array(ARGV))

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: dacpclient
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jurriaan Pruis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dnssd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A DACP (iTunes Remote protocol) client written in the wonderful Ruby
+  language
+email:
+- email@jurriaanpruis.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .rubocop.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- dacpclient.gemspec
+- lib/dacpclient.rb
+- lib/dacpclient/client.rb
+- lib/dacpclient/dmapbuilder.rb
+- lib/dacpclient/dmapconverter.rb
+- lib/dacpclient/dmapparser.rb
+- lib/dacpclient/pairingserver.rb
+- lib/dacpclient/tagdefinitions.rb
+- lib/dacpclient/version.rb
+- remoteclient.rb
+homepage: https://github.com/jurriaan/ruby-dacpclient
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: A DACP (iTunes Remote protocol) client written in the wonderful Ruby language
+test_files: []
+has_rdoc: