mumble-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create ruby-1.9.3-p0@mumble_ruby_gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in mumble-ruby.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,76 @@
+mumble-ruby
+    http://www.github.com/perrym5/mumble-ruby
+
+== DESCRIPTION:
+
+Mumble-Ruby is a headless client for the Mumble VOIP application.
+Mumble-Ruby provides the ability to write scripts and bots which interact with mumble servers through a simple DSL.
+Mumble-Ruby also has the ability to stream raw audio from a fifo pipe (mpd) to the mumble server.
+There is huge room for improvement in this library and I am willing to accept all sorts of pull requests so please do.
+
+== INSTALL:
+
+    [sudo] gem install mumble-ruby
+
+== REQUIREMENTS:
+
+* Ruby >= 1.9.2
+* CELT Audio Codec Library version 0.7
+
+== BASIC USAGE:
+
+    # Create client instance for your server
+    cli = Mumble::Client.new('localhost', 64738, 'Mumble Bot', 'password123')
+    # => #<Mumble::Client:0x00000003064fe8 @host="localhost", @port=64738, @username="Mumble Bot", @password="password123", @channels={}, @users={}, @callbacks={}>
+
+    # Set up some callbacks for when you recieve text messages
+    # There are callbacks for every Mumble Protocol Message that a client can recieve
+    # For a reference on those, see the linked PDF at the bottom of the README.
+    cli.on_text_message do |msg|
+        puts msg.message
+    end
+    # => [#<Proc:0x0000000346e5f8@(irb):2>]
+
+    # Initiate the connection to the client
+    cli.connect
+    # => #<Thread:0x000000033d7388 run>
+
+    # Mute and Deafen yourself
+    cli.mute
+    cli.deafen
+
+    # Join the channel titled "Chillen" (this returns the number of bytes written to the socket)
+    cli.join_channel('Chillen')
+    # => 11
+
+    # Get a list of channels
+    cli.channels
+    # Returns a hash of channel_id: ChannelState Messages
+
+    # Join Channel using ID
+    cli.join_channel(0)
+
+    # Join Channel using ChannelState Message
+    cli.join_channel(cli.channels[0])
+
+    # Get a list of users
+    cli.users
+    # Returns a hash of session_id: UserState Messages
+
+    # Text user
+    cli.text_user('perrym5', "Hello there, I'm a robot!")
+    # => 35
+
+    # Start streaming from a FIFO queue of raw PCM data
+    cli.stream_raw_audio('/tmp/mpd.fifo')
+    # => #<Mumble::AudioStream ...>
+
+    # Safely disconnect
+    cli.disconnect
+    # => nil
+
+== MUMBLE PROTOCOL:
+
+The documentation for Mumble's control and voice protocol is a good reference for using this client as all of the callbacks
+are based on the types of messages the Mumble uses to accomplish its tasks.
+You can see it here[https://github.com/mumble-voip/mumble/raw/master/doc/mumble-protocol.pdf].

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/mumble-ruby.rb

@@ -0,0 +1,7 @@
+require 'active_support/inflector.rb'
+require 'mumble-ruby/version'
+require 'mumble-ruby/messages.rb'
+require 'mumble-ruby/connection.rb'
+require 'mumble-ruby/client.rb'
+require 'mumble-ruby/audio_stream.rb'
+require 'mumble-ruby/packet_data_stream.rb'

data/lib/mumble-ruby/audio_stream.rb

@@ -0,0 +1,54 @@
+module Mumble
+  class AudioStream
+    def initialize(type, target, encoder, file, connection)
+      @type = type
+      @target = target
+      @encoder = encoder
+      @file = File.open(file, 'rb')
+      @conn = connection
+      @seq = 0
+      @num_frames = 6
+      @compressed_size = [@encoder.vbr_rate / 800, 127].min
+      @pds = PacketDataStream.new
+
+      @queue = Queue.new
+      @producer = spawn_thread :produce
+      @consumer = spawn_thread :consume
+    end
+
+    private
+    def packet_header
+      ((@type << 5) | @target).chr
+    end
+
+    def produce
+      pcm_data = @file.read(@encoder.frame_size * 2)
+      @queue << @encoder.encode(pcm_data, @compressed_size)
+    end
+
+    def consume
+      @seq %= 1000000 # Keep sequence number reasonable for long runs
+
+      @pds.rewind
+      @seq += @num_frames
+      @pds.put_int @seq
+
+      @num_frames.times do |i|
+        frame = @queue.pop
+        len = frame.size
+        len = len | 0x80 if i < @num_frames - 1
+        @pds.append len
+        @pds.append_block frame
+      end
+
+      size = @pds.size
+      @pds.rewind
+      data = [packet_header, @pds.get_block(size)].flatten.join
+      @conn.send_udp_packet data
+    end
+
+    def spawn_thread(sym)
+      Thread.new { loop { send sym } }
+    end
+  end
+end

data/lib/mumble-ruby/client.rb

@@ -0,0 +1,210 @@
+require 'thread'
+
+module Mumble
+  class ChannelNotFound < StandardError; end
+  class UserNotFound < StandardError; end
+  class NoSupportedCodec < StandardError; end
+
+  CODEC_ALPHA = 0
+  CODEC_BETA = 3
+
+  class Client
+    attr_reader :host, :port, :username, :password, :users, :channels
+
+    def initialize(host, port=64738, username="Ruby Client", password="")
+      @host = host
+      @port = port
+      @username = username
+      @password = password
+      @users, @channels = {}, {}
+      @callbacks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def connect
+      @conn = Connection.new @host, @port
+      @conn.connect
+
+      create_encoder
+      version_exchange
+      authenticate
+      init_callbacks
+
+      @read_thread = spawn_thread :read
+      @ping_thread = spawn_thread :ping
+    end
+
+    def disconnect
+      @encoder.destroy
+      @read_thread.kill
+      @ping_thread.kill
+      @conn.disconnect
+    end
+
+    def me
+      @users[@session]
+    end
+
+    def current_channel
+      @channels[me.channel_id]
+    end
+
+    def stream_raw_audio(file)
+      raise NoSupportedCodec unless @codec
+      AudioStream.new(@codec, 0, @encoder, file, @conn)
+    end
+
+    Messages.all_types.each do |msg_type|
+      define_method "on_#{msg_type}" do |&block|
+        @callbacks[msg_type] << block
+      end
+
+      define_method "send_#{msg_type}" do |opts|
+        @conn.send_message(msg_type, opts)
+      end
+    end
+
+    def mute(bool=true)
+      send_user_state self_mute: bool
+    end
+
+    def deafen(bool=true)
+      send_user_state self_deaf: bool
+    end
+
+    def join_channel(channel)
+      send_user_state({
+        session: me.session,
+        channel_id: channel_id(channel)
+      })
+    end
+
+    def text_user(user, string)
+      send_text_message({
+        session: [user_session(user)],
+        message: string
+      })
+    end
+
+    def text_channel(channel, string)
+      send_text_message({
+        channel_id: [channel_id(channel)],
+        message: string
+      })
+    end
+
+    def user_stats(user)
+      send_user_stats session: user_session(user)
+    end
+
+    def find_user(name)
+      @users.values.find { |u| u.name == name }
+    end
+
+    def find_channel(name)
+      @channels.values.find { |u| u.name == name }
+    end
+
+    private
+    def spawn_thread(sym)
+      Thread.new { loop { send sym } }
+    end
+
+    def read
+      message = @conn.read_message
+      sym = message.class.to_s.demodulize.underscore.to_sym
+      run_callbacks sym, message
+    end
+
+    def ping
+      send_ping timestamp: Time.now.to_i
+      sleep(20)
+    end
+
+    def run_callbacks(sym, *args)
+      @callbacks[sym].each { |c| c.call *args }
+    end
+
+    def init_callbacks
+      on_server_sync do |message|
+        @session = message.session
+      end
+      on_channel_state do |message|
+        @channels[message.channel_id] = message
+      end
+      on_channel_remove do |message|
+        @channels.delete(message.channel_id)
+      end
+      on_user_state do |message|
+        @users[message.session] = message
+      end
+      on_user_remove do |message|
+        @users.delete(message.session)
+      end
+      on_codec_version do |message|
+        codec_negotiation(message.alpha, message.beta)
+      end
+    end
+
+    def create_encoder
+      @encoder = Celt::Encoder.new 48000, 480, 1
+      @encoder.prediction_request = 0
+      @encoder.vbr_rate = 60000
+    end
+
+    def version_exchange
+      send_version({
+        version: encode_version(1, 2, 3),
+        release: "mumble-ruby #{Mumble::VERSION}",
+        os: %x{uname -o}.strip,
+        os_version: %x{uname -v}.strip
+      })
+    end
+
+    def authenticate
+      send_authenticate({
+        username: @username,
+        password: @password,
+        celt_versions: [@encoder.bitstream_version]
+      })
+    end
+
+    def codec_negotiation(alpha, beta)
+      @codec = case @encoder.bitstream_version
+               when alpha then Mumble::CODEC_ALPHA
+               when beta then Mumble::CODEC_BETA
+               end
+    end
+
+    def channel_id(channel)
+      id = case channel
+           when Messages::ChannelState
+             channel.channel_id
+           when Fixnum
+             channel
+           when String
+             find_channel(channel).channel_id
+           end
+
+      raise ChannelNotFound unless @channels.has_key? id
+      id
+    end
+
+    def user_session(user)
+      id = case user
+           when Messages::ChannelState
+             user.session
+           when Fixnum
+             user
+           when String
+             find_user(user).session
+           end
+
+      raise UserNotFound unless @users.has_key? id
+      id
+    end
+
+    def encode_version(major, minor, patch)
+      (major << 16) | (minor << 8) | (patch & 0xFF)
+    end
+  end
+end

data/lib/mumble-ruby/connection.rb

@@ -0,0 +1,83 @@
+require 'socket'
+require 'openssl'
+require 'thread'
+
+module Mumble
+  class Connection
+    def initialize(host, port)
+      @host = host
+      @port = port
+      @write_lock = Mutex.new
+    end
+
+    def connect
+      context = OpenSSL::SSL::SSLContext.new
+      context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      tcp_sock = TCPSocket.new @host, @port
+      @sock = OpenSSL::SSL::SSLSocket.new tcp_sock, context
+      @sock.connect
+    end
+
+    def disconnect
+      @sock.sysclose
+    end
+
+    def read_message
+      header = read_data 6
+      type, len = header.unpack Messages::HEADER_FORMAT
+      data = read_data len
+      if type == message_type(:udp_tunnel)
+        # UDP Packet -- No Protobuf
+        message = message_class(:udp_tunnel).new
+        message.packet = data
+      else
+        message = message_raw type, data
+      end
+      message
+    end
+
+    def send_udp_packet(packet)
+      header = [message_type(:udp_tunnel), packet.length].pack Messages::HEADER_FORMAT
+      send_data(header + packet)
+    end
+
+    def send_message(sym, attrs)
+      type, klass = message(sym)
+      message = klass.new
+      attrs.each { |k, v| message.send("#{k}=", v) }
+      serial = message.serialize_to_string
+      header = [type, serial.size].pack Messages::HEADER_FORMAT
+      send_data(header + serial)
+    end
+
+    private
+    def send_data(data)
+      @write_lock.synchronize do
+        @sock.syswrite data
+      end
+    end
+
+    def read_data(len)
+      @sock.sysread len
+    end
+
+    def message(obj)
+      return message_type(obj), message_class(obj)
+    end
+
+    def message_type(obj)
+      if obj.is_a? Protobuf::Message
+        obj = obj.class.to_s.demodulize.underscore.to_sym
+      end
+      Messages.sym_to_type(obj)
+    end
+
+    def message_class(obj)
+      Messages.type_to_class(message_type(obj))
+    end
+
+    def message_raw(type, data)
+      Messages.raw_to_obj(type, data)
+    end
+  end
+end

data/lib/mumble-ruby/messages.rb

@@ -0,0 +1,344 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: Mumble.proto>
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module Mumble
+  module Messages
+    ::Protobuf::OPTIONS[:optimize_for] = :SPEED
+    HEADER_FORMAT = "nN"
+
+    @@sym_to_type = {
+      version: 0,
+      udp_tunnel: 1,
+      authenticate: 2,
+      ping: 3,
+      reject: 4,
+      server_sync: 5,
+      channel_remove: 6,
+      channel_state: 7,
+      user_remove: 8,
+      user_state: 9,
+      ban_list: 10,
+      text_message: 11,
+      permission_denied: 12,
+      acl: 13,
+      query_users: 14,
+      crypt_setup: 15,
+      context_action_add: 16,
+      context_action: 17,
+      user_list: 18,
+      voice_target: 19,
+      permission_query: 20,
+      codec_version: 21,
+      user_stats: 22,
+      request_blob: 23,
+      server_config: 24
+    }
+
+    @@type_to_sym = @@sym_to_type.invert
+
+    class << self
+      def all_types
+        return @@sym_to_type.keys
+      end
+
+      def sym_to_type(sym)
+        @@sym_to_type[sym]
+      end
+
+      def type_to_class(type)
+        const_get(@@type_to_sym[type].to_s.camelcase)
+      end
+
+      def raw_to_obj(type, data)
+        message = type_to_class(type).new
+        message.parse_from_string(data)
+        message
+      end
+    end
+
+    class Version < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :version, 1
+      optional :string, :release, 2
+      optional :string, :os, 3
+      optional :string, :os_version, 4
+    end
+    class UdpTunnel < ::Protobuf::Message
+      defined_in __FILE__
+      required :bytes, :packet, 1
+    end
+    class Authenticate < ::Protobuf::Message
+      defined_in __FILE__
+      optional :string, :username, 1
+      optional :string, :password, 2
+      repeated :string, :tokens, 3
+      repeated :int32, :celt_versions, 4
+    end
+    class Ping < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint64, :timestamp, 1
+      optional :uint32, :good, 2
+      optional :uint32, :late, 3
+      optional :uint32, :lost, 4
+      optional :uint32, :resync, 5
+      optional :uint32, :udp_packets, 6
+      optional :uint32, :tcp_packets, 7
+      optional :float, :udp_ping_avg, 8
+      optional :float, :udp_ping_var, 9
+      optional :float, :tcp_ping_avg, 10
+      optional :float, :tcp_ping_var, 11
+    end
+    class Reject < ::Protobuf::Message
+      defined_in __FILE__
+      class RejectType < ::Protobuf::Enum
+        defined_in __FILE__
+        None = value(:None, 0)
+        WrongVersion = value(:WrongVersion, 1)
+        InvalidUsername = value(:InvalidUsername, 2)
+        WrongUserPW = value(:WrongUserPW, 3)
+        WrongServerPW = value(:WrongServerPW, 4)
+        UsernameInUse = value(:UsernameInUse, 5)
+        ServerFull = value(:ServerFull, 6)
+        NoCertificate = value(:NoCertificate, 7)
+      end
+      optional :RejectType, :type, 1
+      optional :string, :reason, 2
+    end
+    class ServerConfig < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :max_bandwidth, 1
+      optional :string, :welcome_text, 2
+      optional :bool, :allow_html, 3
+      optional :uint32, :message_length, 4
+      optional :uint32, :image_message_length, 5
+    end
+    class ServerSync < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :session, 1
+      optional :uint32, :max_bandwidth, 2
+      optional :string, :welcome_text, 3
+      optional :uint64, :permissions, 4
+    end
+    class ChannelRemove < ::Protobuf::Message
+      defined_in __FILE__
+      required :uint32, :channel_id, 1
+    end
+    class ChannelState < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :channel_id, 1
+      optional :uint32, :parent, 2
+      optional :string, :name, 3
+      repeated :uint32, :links, 4
+      optional :string, :description, 5
+      repeated :uint32, :links_add, 6
+      repeated :uint32, :links_remove, 7
+      optional :bool, :temporary, 8, :default => false
+      optional :int32, :position, 9, :default => 0
+      optional :bytes, :description_hash, 10
+    end
+    class UserRemove < ::Protobuf::Message
+      defined_in __FILE__
+      required :uint32, :session, 1
+      optional :uint32, :actor, 2
+      optional :string, :reason, 3
+      optional :bool, :ban, 4
+    end
+    class UserState < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :session, 1
+      optional :uint32, :actor, 2
+      optional :string, :name, 3
+      optional :uint32, :user_id, 4
+      optional :uint32, :channel_id, 5
+      optional :bool, :mute, 6
+      optional :bool, :deaf, 7
+      optional :bool, :suppress, 8
+      optional :bool, :self_mute, 9
+      optional :bool, :self_deaf, 10
+      optional :bytes, :texture, 11
+      optional :bytes, :plugin_context, 12
+      optional :string, :plugin_identity, 13
+      optional :string, :comment, 14
+      optional :string, :hash, 15
+      optional :bytes, :comment_hash, 16
+      optional :bytes, :texture_hash, 17
+      optional :bool, :priority_speaker, 18
+      optional :bool, :recording, 19
+    end
+    class BanList < ::Protobuf::Message
+      defined_in __FILE__
+      class BanEntry < ::Protobuf::Message
+        defined_in __FILE__
+        required :bytes, :address, 1
+        required :uint32, :mask, 2
+        optional :string, :name, 3
+        optional :string, :hash, 4
+        optional :string, :reason, 5
+        optional :string, :start, 6
+        optional :uint32, :duration, 7
+      end
+      repeated :BanEntry, :bans, 1
+      optional :bool, :query, 2, :default => false
+    end
+    class TextMessage < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :actor, 1
+      repeated :uint32, :session, 2
+      repeated :uint32, :channel_id, 3
+      repeated :uint32, :tree_id, 4
+      required :string, :message, 5
+    end
+    class PermissionDenied < ::Protobuf::Message
+      defined_in __FILE__
+      class DenyType < ::Protobuf::Enum
+        defined_in __FILE__
+        Text = value(:Text, 0)
+        Permission = value(:Permission, 1)
+        SuperUser = value(:SuperUser, 2)
+        ChannelName = value(:ChannelName, 3)
+        TextTooLong = value(:TextTooLong, 4)
+        H9K = value(:H9K, 5)
+        TemporaryChannel = value(:TemporaryChannel, 6)
+        MissingCertificate = value(:MissingCertificate, 7)
+        UserName = value(:UserName, 8)
+        ChannelFull = value(:ChannelFull, 9)
+      end
+      optional :uint32, :permission, 1
+      optional :uint32, :channel_id, 2
+      optional :uint32, :session, 3
+      optional :string, :reason, 4
+      optional :DenyType, :type, 5
+      optional :string, :name, 6
+    end
+    class Acl < ::Protobuf::Message
+      defined_in __FILE__
+      class ChanGroup < ::Protobuf::Message
+        defined_in __FILE__
+        required :string, :name, 1
+        optional :bool, :inherited, 2, :default => true
+        optional :bool, :inherit, 3, :default => true
+        optional :bool, :inheritable, 4, :default => true
+        repeated :uint32, :add, 5
+        repeated :uint32, :remove, 6
+        repeated :uint32, :inherited_members, 7
+      end
+      class ChanACL < ::Protobuf::Message
+        defined_in __FILE__
+        optional :bool, :apply_here, 1, :default => true
+        optional :bool, :apply_subs, 2, :default => true
+        optional :bool, :inherited, 3, :default => true
+        optional :uint32, :user_id, 4
+        optional :string, :group, 5
+        optional :uint32, :grant, 6
+        optional :uint32, :deny, 7
+      end
+      required :uint32, :channel_id, 1
+      optional :bool, :inherit_acls, 2, :default => true
+      repeated :ChanGroup, :groups, 3
+      repeated :ChanACL, :acls, 4
+      optional :bool, :query, 5, :default => false
+    end
+    class QueryUsers < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :uint32, :ids, 1
+      repeated :string, :names, 2
+    end
+    class CryptSetup < ::Protobuf::Message
+      defined_in __FILE__
+      optional :bytes, :key, 1
+      optional :bytes, :client_nonce, 2
+      optional :bytes, :server_nonce, 3
+    end
+    class ContextActionAdd < ::Protobuf::Message
+      defined_in __FILE__
+      class Context < ::Protobuf::Enum
+        defined_in __FILE__
+        Server = value(:Server, 1)
+        Channel = value(:Channel, 2)
+        User = value(:User, 4)
+      end
+      required :string, :action, 1
+      required :string, :text, 2
+      optional :uint32, :context, 3
+    end
+    class ContextAction < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :session, 1
+      optional :uint32, :channel_id, 2
+      required :string, :action, 3
+    end
+    class UserList < ::Protobuf::Message
+      defined_in __FILE__
+      class User < ::Protobuf::Message
+        defined_in __FILE__
+        required :uint32, :user_id, 1
+        optional :string, :name, 2
+      end
+      repeated :User, :users, 1
+    end
+    class VoiceTarget < ::Protobuf::Message
+      defined_in __FILE__
+      class Target < ::Protobuf::Message
+        defined_in __FILE__
+        repeated :uint32, :session, 1
+        optional :uint32, :channel_id, 2
+        optional :string, :group, 3
+        optional :bool, :links, 4, :default => false
+        optional :bool, :children, 5, :default => false
+      end
+      optional :uint32, :id, 1
+      repeated :Target, :targets, 2
+    end
+    class PermissionQuery < ::Protobuf::Message
+      defined_in __FILE__
+      optional :uint32, :channel_id, 1
+      optional :uint32, :permissions, 2
+      optional :bool, :flush, 3, :default => false
+    end
+    class CodecVersion < ::Protobuf::Message
+      defined_in __FILE__
+      required :int32, :alpha, 1
+      required :int32, :beta, 2
+      required :bool, :prefer_alpha, 3, :default => true
+    end
+    class UserStats < ::Protobuf::Message
+      defined_in __FILE__
+      class Stats < ::Protobuf::Message
+        defined_in __FILE__
+        optional :uint32, :good, 1
+        optional :uint32, :late, 2
+        optional :uint32, :lost, 3
+        optional :uint32, :resync, 4
+      end
+      optional :uint32, :session, 1
+      optional :bool, :stats_only, 2, :default => false
+      repeated :bytes, :certificates, 3
+      optional :Stats, :from_client, 4
+      optional :Stats, :from_server, 5
+      optional :uint32, :udp_packets, 6
+      optional :uint32, :tcp_packets, 7
+      optional :float, :udp_ping_avg, 8
+      optional :float, :udp_ping_var, 9
+      optional :float, :tcp_ping_avg, 10
+      optional :float, :tcp_ping_var, 11
+      optional :Version, :version, 12
+      repeated :int32, :celt_versions, 13
+      optional :bytes, :address, 14
+      optional :uint32, :bandwidth, 15
+      optional :uint32, :onlinesecs, 16
+      optional :uint32, :idlesecs, 17
+      optional :bool, :strong_certificate, 18, :default => false
+    end
+    class RequestBlob < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :uint32, :session_texture, 1
+      repeated :uint32, :session_comment, 2
+      repeated :uint32, :channel_description, 3
+    end
+  end
+end

data/lib/mumble-ruby/mumble.proto

@@ -0,0 +1,276 @@
+package MumbleProto;
+
+option optimize_for = SPEED;
+
+message	Version {
+	optional uint32 version = 1;
+	optional string release = 2;
+	optional string os = 3;
+	optional string os_version = 4;
+}
+
+message UDPTunnel {
+	required bytes packet = 1;
+}
+
+message Authenticate {
+	optional string username = 1;
+	optional string password = 2;
+	repeated string tokens = 3;
+	repeated int32 celt_versions = 4;
+}
+
+message Ping {
+	optional uint64 timestamp = 1;
+	optional uint32 good = 2;
+	optional uint32 late = 3;
+	optional uint32 lost = 4;
+	optional uint32 resync = 5;
+	optional uint32 udp_packets = 6;
+	optional uint32 tcp_packets = 7;
+	optional float udp_ping_avg = 8;
+	optional float udp_ping_var = 9;
+	optional float tcp_ping_avg = 10;
+	optional float tcp_ping_var = 11;
+}
+
+message Reject {
+	enum RejectType {
+		None = 0;
+		WrongVersion = 1;
+		InvalidUsername = 2;
+		WrongUserPW = 3;
+		WrongServerPW = 4;
+		UsernameInUse = 5;
+		ServerFull = 6;
+		NoCertificate = 7;
+	}
+	optional RejectType type = 1;
+	optional string reason = 2;
+}
+
+message ServerConfig {
+	optional uint32 max_bandwidth = 1;
+	optional string welcome_text = 2;
+	optional bool allow_html = 3;
+	optional uint32 message_length = 4;
+	optional uint32 image_message_length = 5;
+}
+
+message ServerSync {
+	optional uint32 session = 1;
+	optional uint32 max_bandwidth = 2;
+	optional string welcome_text = 3;
+	optional uint64 permissions = 4;
+}
+
+message ChannelRemove {
+	required uint32 channel_id = 1;
+}
+
+message ChannelState {
+	optional uint32 channel_id = 1;
+	optional uint32 parent = 2;
+	optional string name = 3;
+	repeated uint32 links = 4;
+	optional string description = 5;
+	repeated uint32 links_add = 6;
+	repeated uint32 links_remove = 7;
+	optional bool temporary = 8 [default = false];
+	optional int32 position = 9 [default = 0];
+	optional bytes description_hash = 10;
+}
+
+message UserRemove {
+	required uint32 session = 1;
+	optional uint32 actor = 2;
+	optional string reason = 3;
+	optional bool ban = 4;
+}
+
+message UserState {
+	optional uint32 session = 1;
+	optional uint32 actor = 2;
+	optional string name = 3;
+	optional uint32 user_id = 4;
+	optional uint32 channel_id = 5;
+	optional bool mute = 6;
+	optional bool deaf = 7;
+	optional bool suppress = 8;
+	optional bool self_mute = 9;
+	optional bool self_deaf = 10;
+	optional bytes texture = 11;
+	optional bytes plugin_context = 12;
+	optional string plugin_identity = 13;
+	optional string comment = 14;
+	optional string hash = 15;
+	optional bytes comment_hash = 16;
+	optional bytes texture_hash = 17;
+	optional bool priority_speaker = 18;
+	optional bool recording = 19;
+}
+
+message BanList {
+	message BanEntry {
+		required bytes address = 1;
+		required uint32 mask = 2;
+		optional string name = 3;
+		optional string hash = 4;
+		optional string reason = 5;
+		optional string start = 6;
+		optional uint32 duration = 7;
+	}
+	repeated BanEntry bans = 1;
+	optional bool query = 2 [default = false];
+}
+
+message TextMessage {
+	optional uint32 actor = 1;
+	repeated uint32 session = 2;
+	repeated uint32 channel_id = 3;
+	repeated uint32 tree_id = 4;
+	required string message = 5;
+}
+
+message PermissionDenied {
+	enum DenyType {
+		Text = 0;
+		Permission = 1;
+		SuperUser = 2;
+		ChannelName = 3;
+		TextTooLong = 4;
+		H9K = 5;
+		TemporaryChannel = 6;
+		MissingCertificate = 7;
+		UserName = 8;
+		ChannelFull = 9;
+	}
+	optional uint32 permission = 1;
+	optional uint32 channel_id = 2;
+	optional uint32 session = 3;
+	optional string reason = 4;
+	optional DenyType type = 5;
+	optional string name = 6;
+}
+
+message ACL {
+	message ChanGroup {
+		required string name = 1;
+		optional bool inherited = 2 [default = true];
+		optional bool inherit = 3 [default = true];
+		optional bool inheritable = 4 [default = true];
+		repeated uint32 add = 5;
+		repeated uint32 remove = 6;
+		repeated uint32 inherited_members = 7;
+	}
+	message ChanACL {
+		optional bool apply_here = 1 [default = true];
+		optional bool apply_subs = 2 [default = true];
+		optional bool inherited = 3 [default = true];
+		optional uint32 user_id = 4;
+		optional string group = 5;
+		optional uint32 grant = 6;
+		optional uint32 deny = 7;
+	}
+	required uint32 channel_id = 1;
+	optional bool inherit_acls = 2 [default = true];
+	repeated ChanGroup groups = 3;
+	repeated ChanACL acls = 4;
+	optional bool query = 5 [default = false];
+}
+
+message QueryUsers {
+	repeated uint32 ids = 1;
+	repeated string names = 2;
+}
+
+message CryptSetup {
+	optional bytes key = 1;
+	optional bytes client_nonce = 2;
+	optional bytes server_nonce = 3;
+}
+
+message ContextActionAdd {
+	enum Context {
+		Server = 0x01;
+		Channel = 0x02;
+		User = 0x04;
+	}
+	required string action = 1;
+	required string text = 2;
+	optional uint32 context = 3;
+}
+
+message ContextAction {
+	optional uint32 session = 1;
+	optional uint32 channel_id = 2;
+	required string action = 3;
+}
+
+message UserList {
+	message User {
+		required uint32 user_id = 1;
+		optional string name = 2;
+	}
+	repeated User users = 1;
+}
+
+message VoiceTarget {
+	message Target {
+		repeated uint32 session = 1;
+		optional uint32 channel_id = 2;
+		optional string group = 3;
+		optional bool links = 4 [default = false];
+		optional bool children = 5 [default = false];
+	}
+	optional uint32 id = 1;
+	repeated Target targets = 2;
+}
+
+message PermissionQuery {
+	optional uint32 channel_id = 1;
+	optional uint32 permissions = 2;
+	optional bool flush = 3 [default = false];
+}
+
+message CodecVersion {
+	required int32 alpha = 1;
+	required int32 beta = 2;
+	required bool prefer_alpha = 3 [default = true];
+}
+
+message UserStats {
+	message Stats {
+		optional uint32 good = 1;
+		optional uint32 late = 2;
+		optional uint32 lost = 3;
+		optional uint32 resync = 4;
+	}
+
+	optional uint32 session = 1;
+	optional bool stats_only = 2 [default = false];
+	repeated bytes certificates = 3;
+	optional Stats from_client = 4;
+	optional Stats from_server = 5;
+
+	optional uint32 udp_packets = 6;
+	optional uint32 tcp_packets = 7;
+	optional float udp_ping_avg = 8;
+	optional float udp_ping_var = 9;
+	optional float tcp_ping_avg = 10;
+	optional float tcp_ping_var = 11;
+
+	optional Version version = 12;
+	repeated int32 celt_versions = 13;
+	optional bytes address = 14;
+	optional uint32 bandwidth = 15;
+	optional uint32 onlinesecs = 16;
+	optional uint32 idlesecs = 17;
+	optional bool strong_certificate = 18 [default = false];
+}
+
+message RequestBlob {
+	repeated uint32 session_texture = 1;
+	repeated uint32 session_comment = 2;
+	repeated uint32 channel_description = 3;
+}

data/lib/mumble-ruby/packet_data_stream.rb

@@ -0,0 +1,157 @@
+module Mumble
+  class PacketDataStream
+    def initialize(data=nil)
+      @data = data || 0.chr * 1024
+      @data = @data.split ''
+      @pos = 0
+      @ok = true
+      @capacity = @data.size
+    end
+
+    def valid
+      @ok
+    end
+
+    def size
+      @pos
+    end
+
+    def left
+      @capacity - @pos
+    end
+
+    def append(val)
+      if @pos < @capacity
+        @data[@pos] = val.chr
+        skip
+      else
+        @ok = false
+      end
+    end
+
+    def append_block(data)
+      len = data.size
+      if len < left
+        @data[@pos, len] = data.split('')
+        skip len
+      else
+        @ok = false
+      end
+    end
+
+    def get_block(len)
+      if len < left
+        ret = @data[@pos, len]
+        skip len
+      else
+        @ok = false
+        ret = []
+      end
+      ret
+    end
+
+    def get_next
+      if @pos < @capacity
+        ret = @data[@pos].ord
+        skip
+      else
+        ret = 0
+        @ok = false
+      end
+      ret
+    end
+
+    def rewind
+      @pos = 0
+    end
+
+    def skip(len=1)
+      len < left ? @pos += len : @ok = false
+    end
+
+    def put_int(int)
+      if !(int & 0x8000000000000000).zero? && (~int < 0x100000000)
+        int = ~int
+        puts int
+        if int <= 0x3
+          # Shortcase for -1 to -4
+          append(0xFC | int)
+        else
+          append(0xF8)
+        end
+      end
+
+      if int < 0x80
+        # Need top bit clear
+        append(int)
+      elsif int < 0x4000
+        # Need top two bits clear
+        append((int >> 8) | 0x80)
+        append(int & 0xFF)
+      elsif int < 0x200000
+        # Need top three bits clear
+        append((int >> 16) | 0xC0)
+        append((int >> 8) & 0xFF)
+        append(int & 0xFF)
+      elsif int < 0x10000000
+        # Need top four bits clear
+        append((int >> 24) | 0xE0)
+        append((int >> 16) & 0xFF)
+        append((int >> 8) & 0xFF)
+        append(int & 0xFF)
+      elsif int < 0x100000000
+        # It's a full 32-bit integer.
+        append(0xF0)
+        append((int >> 24) & 0xFF)
+        append((int >> 16) & 0xFF)
+        append((int >> 8) & 0xFF)
+        append(int & 0xFF)
+      else
+        # It's a 64-bit value.
+        append(0xF4)
+        append((int >> 56) & 0xFF)
+        append((int >> 48) & 0xFF)
+        append((int >> 40) & 0xFF)
+        append((int >> 32) & 0xFF)
+        append((int >> 24) & 0xFF)
+        append((int >> 16) & 0xFF)
+        append((int >> 8) & 0xFF)
+        append(int & 0xFF)
+      end
+    end
+
+    def get_int
+      v = get_next
+      int = 0
+
+      if (v & 0x80) == 0x00
+        int = v & 0x7F
+      elsif (v & 0xC0) == 0x80
+        int = (v & 0x3F) << 8 | get_next
+      elsif (v & 0xF0) == 0xF0
+        x = v & 0xFC
+        if x == 0xF0
+          int = get_next << 24 | get_next << 16 | get_next << 8 | get_next
+        elsif x == 0xF4
+          int = get_next << 56 | get_next << 48 | get_next << 40 | get_next << 32 |
+                get_next << 24 | get_next << 16 | get_next << 8  | get_next
+        elsif x == 0xF8
+          int = get_int
+          int = ~int
+        elsif x == 0xFC
+          int = v & 0x03
+          int = ~int
+        else
+          @ok = false
+          int = 0
+        end
+      elsif (v & 0xF0) == 0xE0
+        int = (v & 0x0F) << 24 | get_next << 16 | get_next << 8 | get_next
+      elsif (v & 0xE0) == 0xC0
+        int = (v & 0x1F) << 16 | get_next << 8 | get_next
+      end
+
+      return int
+    end
+  end
+end

data/lib/mumble-ruby/version.rb

@@ -0,0 +1,3 @@
+module Mumble
+  VERSION = "0.0.1"
+end

data/mumble-ruby.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mumble-ruby/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matthew Perry"]
+  gem.email         = ["perrym5@rpi.edu"]
+  gem.description   = %q{Ruby API for interacting with a mumble server}
+  gem.summary       = %q{Implements the mumble VOIP protocol in ruby for more easily writing clients.}
+  gem.homepage      = "http://www.github.com/perrym5/mumble-ruby"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "mumble-ruby"
+  gem.require_paths = ["lib"]
+  gem.version       = Mumble::VERSION
+
+  gem.add_dependency "activesupport"
+  gem.add_dependency "celt-ruby"
+
+  gem.add_development_dependency "ruby_protobuf"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: mumble-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Perry
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &11094520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *11094520
+- !ruby/object:Gem::Dependency
+  name: celt-ruby
+  requirement: &11093120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *11093120
+- !ruby/object:Gem::Dependency
+  name: ruby_protobuf
+  requirement: &11091560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11091560
+description: Ruby API for interacting with a mumble server
+email:
+- perrym5@rpi.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/mumble-ruby.rb
+- lib/mumble-ruby/audio_stream.rb
+- lib/mumble-ruby/client.rb
+- lib/mumble-ruby/connection.rb
+- lib/mumble-ruby/messages.rb
+- lib/mumble-ruby/mumble.proto
+- lib/mumble-ruby/packet_data_stream.rb
+- lib/mumble-ruby/version.rb
+- mumble-ruby.gemspec
+homepage: http://www.github.com/perrym5/mumble-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Implements the mumble VOIP protocol in ruby for more easily writing clients.
+test_files: []