ruckus 0.5.4

data/lib/ruckus/structure/beforebacks.rb

@@ -0,0 +1,28 @@
+module Ruckus
+    module StructureBeforeCallbacks
+        def self.included(klass)
+            klass.extend(ClassMethods)
+
+            klass.class_eval {
+                class_inheritable_array :before_callbacks
+                write_inheritable_array :before_callbacks, []
+            }
+        end
+
+        def before_render_hook
+            self.class.before_callbacks.each {|cb| self.instance_eval(&cb)}
+        end
+
+        module ClassMethods
+            def before_render(arg=nil, &block)
+                if not block_given?
+                    raise "need a callback function" if not arg
+                    arg = arg.intern if not arg.kind_of? Symbol
+                    block = lambda { send(arg) }
+                end
+
+                self.before_callbacks << block
+            end
+        end
+    end
+end

data/lib/ruckus/structure/defaults.rb

@@ -0,0 +1,57 @@
+module Ruckus
+    module StructureDefaultValues
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+
+        def final_initialization_hook
+            instance_variables.grep(/^@with_.*/).each do |v|
+                v =~ /@with_(.*)/
+                var = $1
+                send((var + "=").intern, instance_variable_get(v.intern))
+            end
+            super
+        end
+
+        # XXX probably not needed
+#         def template_entry_added_hook(obj)
+#             obj.instance_variables.grep(/^@with_.*/).each do |v|
+#                 v =~ /@with_(.*)/
+#                 var = $1
+#                 obj.send((var + "=").intern, obj.instance_variable_get(v.intern))
+#             end
+#             super
+#         end
+
+        def method_missing_hook(meth, args)
+            m = meth.to_s
+            setter = (m[-1].chr == "=") ? true : false
+            m = m[0..-2] if setter
+            if setter and (field = self[m.intern])
+                if(field.kind_of? Structure)
+                    if args[0].kind_of? field.class
+                        args[0].each_field do |name, f|
+                            field.value = f.value
+                        end
+                    else
+                        if((deft = field.instance_variable_get :@default_field))
+                            field.send(deft.to_s + "=", args[0])
+                            return false
+                        else
+                            puts "WARNING: attempt to set structure field with no default_field declared"
+                        end
+                    end
+                end
+            end
+            true
+        end
+
+        module ClassMethods
+            def default_field(f)
+                self.initializers << lambda do
+                    @default_field = f
+                end
+            end
+        end
+    end
+end

data/lib/ruckus/structure/factory.rb

@@ -0,0 +1,42 @@
+module Ruckus
+    module StructureDetectFactory
+        def factory?
+            self.respond_to? :factory
+        end
+
+        def structure_field_def_hook(*a)
+            args = a[0]
+            opts = args[0].respond_to?(:has_key?) ? args[0] : args[1]
+            include StructureFactory if opts.try(:has_key?, :decides)
+            super
+        end
+    end
+
+    module StructureFactory
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+            def factory(str)
+                orig = str.clone
+                (tmp = self.new).capture(str)
+                tmp.each_field do |n, f|
+                    if (m = f.try(:decides))
+                        klass = m[f.value]
+                        if klass
+                            o = derive_search_module.const_get(klass.to_s.class_name).new
+                            if o.class.factory?
+                                o, orig = o.class.factory(orig)
+                            else
+                                orig = o.capture(orig)
+                            end
+                            return o, orig
+                        end
+                    end
+                end
+                return false
+            end
+        end
+    end
+end

data/lib/ruckus/structure/fixupfields.rb

@@ -0,0 +1,16 @@
+module Ruckus
+    module StructureFixupFieldNames
+        def structure_field_def_hook(*a)
+            args = a[0]
+            if args[0] and args[0].kind_of? Symbol
+                if args[1]
+                    args[1][:name] = args[0]
+                else
+                    args[1] = { :name => args[0] }
+                end
+                args.shift
+            end
+            super
+        end
+    end
+end

data/lib/ruckus/structure/initializers.rb

@@ -0,0 +1,14 @@
+module Ruckus
+    module StructureInitializers
+        def self.included(klass)
+            klass.class_eval {
+                class_inheritable_array :initializers
+                write_inheritable_array :initializers, []
+            }
+        end
+
+        def final_initialization_hook
+            self.initializers.each {|cb| self.instance_eval(&cb) }
+        end
+    end
+end

data/lib/ruckus/structure/relate.rb

@@ -0,0 +1,34 @@
+module Ruckus
+    module StructureRelateDeclaration
+        def class_method_missing_hook(meth, *args)
+            if meth.to_s =~ /^relate_(.*)/
+                relate($1.intern, *args)
+                return false
+            end
+            true
+        end
+
+        def relate(attr, field, opts={})
+            opts[:through] ||= :value
+            raise "need a valid field to relate" if not field
+            raise "need :to argument" if not opts[:to]
+
+            self.initializers << lambda do
+                f = send(field)
+
+                case attr
+                when :value
+                    f.value = opts[:through]
+                    f.instance_eval { @from_field = opts[:to] }
+                when :size
+                    f.instance_eval {
+                        @in_size = {
+                            :meth => opts[:through],
+                            :from_field => opts[:to]
+                        }
+                    }
+                end
+            end
+        end
+    end
+end

data/lib/ruckus/structure/replacement.rb

@@ -0,0 +1,30 @@
+module Ruckus
+    module StructureAllowFieldReplacement
+        def template_entry_added_hook(obj)
+            ## -------------------------------------------
+            ## a quick dance to allow fields to replace other
+            ## fields
+
+            # check to see if it already exists, in which
+            # case we want to replace the previous definition
+            found = false
+            @value.each_with_index do |x,i|
+                if x.try(:name) == obj.try(:name)
+                    found = i
+                    break
+                end
+            end
+
+            # it didn't exist, so add it to the structure
+            if found
+                # it did exist, so update the names index
+                # and the previous entry in the structure
+
+                self.class.structure_field_names[obj.try(:name)] = found
+                @value[found] = obj
+            else
+                false
+            end
+        end
+    end
+end

data/lib/ruckus/structure/searchmods.rb

@@ -0,0 +1,33 @@
+module Ruckus
+    module StructureSearchModules
+        def self.included(klass)
+            klass.class_eval {
+                class_inheritable_array :search_modules
+                write_inheritable_array :search_modules, []
+            }
+
+            klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+            def derive_search_module
+                if self.search_modules.empty?
+                    return Ruckus
+                else
+                    mod = Module.new
+                    self.search_modules.each do |m|
+                        mod.module_eval "include #{ m.to_s.class_name }"
+                    end
+                    mod.module_eval "include Ruckus"
+                    return mod
+                end
+            end
+
+            def search_module(*args)
+                args.each do |m|
+                    self.search_modules << m
+                end
+            end
+        end
+    end
+end

data/lib/ruckus/structure/structureproxies.rb

@@ -0,0 +1,28 @@
+module Ruckus
+    module StructureProxies
+        class ValueProxy
+            def initialize(target); @t = target; end
+            def method_missing(meth, *args)
+                if meth.to_s.ends_with? "="
+                    @t.send(meth, *args)
+                else
+                    @t.send(meth).send(:value)
+                end
+            end
+        end
+
+        class NodeProxy
+            def initialize(target); @t = target; end
+            def method_missing(meth, *args)
+                if meth.to_s.ends_with? "="
+                    @t.send(meth, *args)
+                else
+                    @t[meth]
+                end
+            end
+        end
+
+        def v; ValueProxy.new(self); end
+        def n; NodeProxy.new(self); end
+    end
+end

data/lib/ruckus/structure/validate.rb

@@ -0,0 +1,12 @@
+require 'pp'
+
+module Ruckus
+    module StructureValidateField
+        def structure_field_def_hook(*a)
+            args = a[0]
+            if [ "value", "name", "size" ].include?(nm = args[0][:name] && args[0][:name].to_s) or (nm and nm.starts_with? "relate_")
+                raise "can't have fields named #{ nm }, because we suck; rename the field"
+            end
+        end
+    end
+end

data/lib/ruckus/structure_shortcuts.rb

@@ -0,0 +1,109 @@
+# === A sort of half-baked DSL for defining packet fields.
+# These are all classmethods of Structure.
+module Ruckus
+    class Structure
+        # Any number, ie
+        #    num :len, :width => 32, :endianness => :little
+        #
+        def self.num(name, opts)
+            add(Number, opts.merge(:name => name))
+        end
+
+        def self.char(*args); with_args(*args) {|name, opts| str opts.merge(:name => name, :size => 1)}; end
+
+        def self.decimal(*args); with_args(*args) {|name, opts| num name, opts.merge(:ascii => true, :radix => 10)}; end
+        def self.hex_number(*args); with_args(*args) {|name, opts| num name, opts.merge(:ascii => true, :radix => 16)}; end
+
+        def self.tag_bit(*args); with_args(*args) {|name, opts| num name, opts.merge(:width => 1, :tag => name)}; end
+
+        # A string (ie, multiple of 8 bits wide) containing all zeroes.
+        # You could also just use
+        #   num :width => whatever, :value => 0
+        #
+        def self.zero_pad(*args)
+            with_args(*args) do |name, opts|
+                str opts.merge(:name => name, :padding => "\x00")
+            end
+        end
+
+        # A bounded string, takes its size from the preceding element
+        #
+        def self.bounded(*args)
+            with_args(*args) do |name, opts|
+                opts[:size] ||= :value
+                opts[:offset] ||= -1
+                str name, opts
+            end
+        end
+
+        # A string.
+        def self.string(*args)
+            with_args(*args) do |name, opts|
+                str opts.merge(:name => name)
+            end
+        end
+
+        # A Null byte
+        def self.mark(*args)
+            with_args(*args) do |name, opts|
+                null opts.merge(:name => name)
+            end
+        end
+
+        # 4-byte IP address (IPv4)
+        def self.ipv4(*args)
+            with_args(*args) do |name, opts|
+                add(Ruckus::IP, opts.merge(:name => name))
+            end
+        end
+
+        def self.choose(name, tag=nil, &block)
+            add(Ruckus::Choice, :name => name, :block => block)
+        end
+
+        def self.base_pad(name, tag=nil)
+            string name, :value => {:offset => :this, :block => lambda do |this|
+                    r = this.root
+                    r = r.find_tag_struct(tag) if tag
+                    if ((k = this.rendered_offset - r.rendered_offset) % 4) != 0
+                        pad = 4 - ((this.rendered_offset - r.rendered_offset) % 4)
+                    else
+                        pad = 0
+                    end
+                    "\x00" * pad
+                end
+            }
+        end
+
+        def self.word_len(*args); with_args(*args) do |name, opts|
+                opts[:value] ||= :size
+                opts[:width] ||= 16
+                opts[:modifier] = lambda {|o, s| s/=2}
+                num name, opts
+            end
+        end
+
+        def self.msg_len(*args); with_args(*args) do |name, opts|
+                opts[:value] = { :block => lambda do |n|
+                        if not n.rendering
+                            begin
+                                n.rendering = true
+                                n.parent_struct.size
+                            ensure
+                                n.rendering = false
+                            end
+                        else
+                            4
+                        end
+                    end
+                }
+                opts[:width] ||= 32
+                num name, opts
+            end
+        end
+    end
+
+    class Padding < Structure
+        base_pad :pad
+    end
+end

data/lib/ruckus/time_t.rb

@@ -0,0 +1,26 @@
+
+module Ruckus
+  class TimeT < Number
+    def initialize(opts={})
+      opts[:width] ||= 32
+      super(opts)
+    end
+
+    def to_human(indent="")
+      "#{indent}#{@name} = #{@value.to_hex} (#{time})"
+    end
+
+    def utc(*args)
+      @value=( Time.utc(*args) ).to_i
+    end
+    alias :gm :utc
+
+    def local(*args)
+      @value=( t=Time.local(*args)).to_i
+    end
+
+    def time
+      Time.at(@value)
+    end
+  end
+end

data/lib/ruckus/vector.rb

@@ -0,0 +1,97 @@
+module Ruckus
+
+    # A vector of count elements of the same class, as in
+    # [elt0] [elt1] ... [eltN]
+    class Vector < Parsel
+
+        # Options include:
+        # * <tt>:class</tt> the class of each element
+        # * <tt>:e_opts</tt> opts to pass when creating each element (:name is always deleted)
+        # * <tt>:count</tt> the number of elements of class :class in the vector. Can be a reference to another field
+        # via :from_field
+        def initialize(opts={})
+            opts[:count] = 0x1fffffff if opts[:count] == :unlimited # grotesque hack XXX
+            opts[:e_opts] ||= {}
+
+            raise "need a class" if not opts[:class] and not opts[:classes_from]
+
+            if opts[:classes_from]
+                if not opts[:keys_from]
+                    raise "need a module to pull keys from (protocol numbers, command IDs, whatever) as :keys_from"
+                end
+
+                begin
+                    @keys = (m = opts[:keys_from]).constants.
+                        select {|x| m.const_get(x).kind_of? Numeric}.
+                        map {|x| [m.const_get(x), x]}.
+                        to_hash
+                rescue => e
+                    raise "can't look up keys:\n #{ e }"
+                end
+
+                begin
+                    @classes = (m = opts[:classes_from]).constants.
+                        select {|x| m.const_get(x).kind_of? Class}.
+                        map do |x|
+                            name = (klass = m.const_get(x)).
+                                     to_s.
+                                     underscore.
+                                     upcase
+                            name = name[name.rindex(":")+1..-1]
+                            [ name, klass ]
+                        end.to_hash
+                rescue => e
+                    raise "can't generate class dictionary:\n #{ e }"
+                end
+
+                raise "need a :key_field or :key_finder" if not opts[:key_field] and not opts[:key_finder]
+            end
+
+            super(opts)
+            @value = Blob.new
+            @value.parent = self
+        end
+
+        def capture(str)
+            count = resolve(@count)
+            if not count
+                raise "You need to provide a :count value to parse a vector; did you give it :size by mistake?"
+            end
+
+            count.downto(1) do |i|
+                break if not str or str.empty?
+
+                if @class
+                    o = @class.new(@e_opts.merge(:parent => self))
+                    str = o.capture(str)
+                    @value << o
+                else
+                    if @key_field
+                        key = parent_struct.send(@key_field)
+                    end
+
+                    if @key_finder
+                        key = @key_finder.call(str)
+                    end
+
+                    begin
+                        o = @classes[@keys[key]].new(@e_opts.merge(:parent => self))
+                        str = o.capture(str)
+                        @value << o
+                    rescue => e
+                        raise "couldn't create an object from key:\n#{ e }"
+                    end
+                end
+            end
+            @count = @value.count
+            str
+        end
+
+        def to_s(off=nil)
+            @rendered_offset = off || 0
+            (@value)? @value.to_s(off) : ""
+        end
+
+    end
+
+end