iZsh-wwmd 0.2.19

data/lib/wwmd/urlparse.rb

@@ -0,0 +1,104 @@
+require 'htmlentities'
+require 'wwmd/class_extensions'
+module WWMD
+
+  # yay for experiments in re-inventing the wheel
+  class URLParse
+    HANDLERS = [:https,:http,:ftp,:file]
+    attr_reader :proto,:location,:path,:script,:rpath,:params,:base_url,:fqpath
+
+    def initialize(*args)
+      # nothing to see here, move along
+    end
+
+    def parse(*args)
+      if args.size == 1
+        base = ""
+        actual = args.shift
+      else
+        base = args.shift
+        actual = args.shift
+      end
+      @proto = @location = @path = @script = @rpath = nil
+      @base = base.to_s
+      @actual = actual
+      if self.has_proto?
+        @base = @actual
+        @actual = ""
+      end
+# does this work for http://location/?  probably not
+      @base += "/" if (!@base.has_ext? || @base.split("/").size == 3)
+      @rpath = make_me_path.join("/")
+      @rpath += "?#{@params}" if @params
+      @path = "/" + @rpath
+      if @rpath.has_ext?
+        @path = "/" + @rpath.dirname
+        @script = @rpath.basename.clip
+      end
+      @script = "" if @script.nil?
+      begin
+        @base_url = @proto + "://" + @location
+      rescue => e
+        dgb = WWMD.debug
+        WWMD.debug = true
+        putd "ERROR in urlparse TRACE:"
+        pp *args
+        putd @proto
+        putd @base
+        putd @actual
+        putd @location
+        WWMD.debug = dbg
+        raise e
+      end
+      @fqpath = @path + @script
+      self
+    end
+
+    def make_me_path
+      @proto,tpath = @base.split(":",2)
+      tpath ||= ""
+      @params = tpath.clop
+      tpath = tpath.clip
+      if @actual.empty?
+        a_path = tpath.split("/").reject { |x| x.empty? }
+      else
+        a_path = tpath.dirname.split("/").reject { |x| x.empty? }
+      end
+      @location = a_path.shift
+      if @actual.clop
+        @params = @actual.clop
+        @actual = @actual.clip
+      end
+      a_path = [] if (@actual =~ (/^\//))
+      b_path = @actual.split("/").reject { |x| x.empty? }
+      a_path.pop if (a_path[-1] =~ /^\?/).kind_of?(Fixnum) && !b_path.empty?
+      c_path = (a_path + @actual.split("/").reject { |x| x.empty? }).flatten
+      d_path = []
+      c_path.each do |x|
+        (d_path.pop;next) if x == ".."
+        next if (x == "." || x =~ /^\?/)
+        d_path << x
+      end
+      return d_path
+    end
+
+    def has_proto?
+      begin
+        return true if HANDLERS.include?(@actual.split(":").first.downcase.to_sym)
+      rescue
+        return false
+      end
+    end
+
+    def to_s
+      return "#{@proto}://#{@location}/#{rpath}"
+    end
+  end
+end
+
+class String
+  def has_ext? #:nodoc:
+    return false if self.basename.split(".",2)[1].empty?
+    return true
+  end
+end

data/lib/wwmd/viewstate.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'nokogiri'
+require 'rexml/document'
+require 'htmlentities'
+require 'wwmd/viewstate/viewstate_utils'
+module WWMD
+  class ViewState
+    include ViewStateUtils
+  end
+end
+require 'wwmd/class_extensions'
+require 'wwmd/viewstate/viewstate'
+require 'wwmd/viewstate/viewstate_types'
+require 'wwmd/viewstate/viewstate_yaml'
+require 'wwmd/viewstate/viewstate_deserializer_methods'
+require 'wwmd/viewstate/viewstate_from_xml'
+require 'wwmd/viewstate/vs_stubs'

data/lib/wwmd/viewstate/viewstate.rb

@@ -0,0 +1,101 @@
+module WWMD
+  class ViewState
+    attr_accessor :b64
+    attr_accessor :obj_queue
+    attr_accessor :mac
+    attr_accessor :debug
+    attr_reader   :raw
+    attr_reader   :stack
+    attr_reader   :bufarr
+    attr_reader   :magic
+    attr_reader   :size
+    attr_reader   :indexed_strings
+    attr_reader   :last_offset
+    attr_reader   :xml
+    attr_reader   :ndoc
+    attr_reader   :obj_counts
+
+    def initialize(b64=nil)
+      @b64 = b64
+      @raw = ""
+      @stack = ""
+      @obj_queue = []
+      @bufarr = []
+      @size = 0
+      @indexed_strings = []
+      @mac = nil
+      @debug = false
+      @obj_counts = {}
+      self.deserialize if b64
+    end
+
+    # mac_enabled?
+    def mac_enabled?
+      return !@mac.nil?
+    end
+
+    # deserialize
+    def deserialize(b64=nil)
+      @obj_queue = []
+      @b64 = b64 if b64
+      @raw = @b64.b64d
+      @bufarr = @raw.scan(/./m)
+      @size = @bufarr.size
+      raise "Invalid ViewState" if not self.magic?
+      @obj_queue << self.deserialize_value
+      if @bufarr.size == 20 then
+        @mac = @bufarr.slice!(0..19).join("")
+        dlog(0x00,"MAC = #{@mac.hexify}")
+      end
+      raise "Error Parsing Viewstate (left: #{@bufarr.size})" if not @bufarr.size == 0
+      return !self.raw.nil?
+    end
+
+    def serialize(objs=nil,version=2)
+      @obj_queue = objs if objs
+      @stack << "\xFF\x01"
+      @stack << @obj_queue.first.serialize
+      @stack << @mac if @mac
+      return !self.stack.nil?
+    end
+
+    def to_xml
+      @xml = REXML::Document.new()
+      header = REXML::Element.new("ViewState")
+      header.add_attribute("version", @magic.b64e)
+      header.add_attribute("version_string", @magic.hexify)
+      header.add_element(@obj_queue.first.to_xml)
+      if self.mac_enabled?
+        max = REXML::Element.new("Mac")
+        max.add_attribute("encoding","hexify")
+        max.add_text(@mac.hexify)
+        header.add_element(max)
+      end
+      @xml.add_element(header)
+      @ndoc = Nokogiri::XML.parse(@xml.to_s)
+      self
+    end
+
+    # xpath search the nokogiri doc if we have one
+    def search(*args)
+      return "No XML" if !@ndoc
+      @ndoc.search(*args)
+    end
+
+    # move pp due to to_xml returning self
+    # this is all for the sake of getting #search to work
+    def pp(*args)
+      return "Undefined" if !@xml
+      @xml.pp(*args)
+    end
+
+    def from_yaml(yaml)
+      @obj_queue = YAML.load(yaml)
+    end
+
+    def to_yaml
+      @obj_queue.to_yaml
+    end
+
+ end
+end

data/lib/wwmd/viewstate/viewstate_deserializer_methods.rb

@@ -0,0 +1,217 @@
+module WWMD
+  class ViewState
+    # complex types
+    def pair(t=nil)
+      dlog t,"next = #{next_type}"
+      VSStubs::VSPair.new(self.deserialize_value,self.deserialize_value)
+    end
+
+    def triplet(t=nil)
+      dlog t,"next = #{next_type}"
+      VSStubs::VSTriplet.new(self.deserialize_value,self.deserialize_value,self.deserialize_value)
+    end
+
+    def type(t=nil)
+      typeref,typeval = self.deserialize_type
+      dlog(t,"typeref = 0x#{typeref.to_s(16)} typeval = #{typeval}")
+      VSStubs::VSType.new(typeref,typeval)
+    end
+
+    def string_formatted(t=nil)
+      typeref,typeval = self.deserialize_type
+      str = self.read_string
+      dlog(t,"typeref = 0x#{typeref.to_s(16)} typeval = #{typeval} string = #{str}")
+      VSStubs::VSStringFormatted.new(typeref,typeval,str)
+    end
+
+    def int_enum(t=nil)
+      typeref,typeval = self.deserialize_type
+      index = self.read_7bit_encoded_int
+      dlog(t,"typeref = 0x#{typeref.to_s(16)} typeval = #{typeval} index = #{index}")
+      VSStubs::VSIntEnum.new(typeref,typeval,index)
+    end
+
+    def binary_serialized(t=nil)
+      count = self.read_7bit_encoded_int
+      dlog(t,count)
+      bin = self.read(count)
+      me = VSStubs::VSBinarySerialized.new()
+      me.set(bin)
+      return me
+    end
+
+    def sparse_array(t=nil)
+      typeref,typeval = self.deserialize_type
+      size  = read_7bit_encoded_int
+      elems = read_7bit_encoded_int
+      dlog(t,"typeref = 0x#{typeref.to_s(16)} typeval = #{typeval} size = #{size} elems = #{elems}")
+      me = VSStubs::VSSparseArray.new(typeref,typeval,size,elems)
+      if elems > size
+        raise "Invalid sparse_array"
+      end
+      (1..elems).each do |i|
+        idx = read_7bit_encoded_int
+        me.add(idx,self.deserialize_value)
+      end
+      return me
+    end
+
+    def hashtable(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSStubs::VSHashtable.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value,self.deserialize_value)
+      end
+      return me
+    end
+
+    def hybrid_dict(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSStubs::VSHybridDict.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value,self.deserialize_value)
+      end
+      return me
+    end
+
+    def array(t=nil)
+      typeref,typeval = self.deserialize_type
+      len = read_7bit_encoded_int
+      dlog(t,"typeref = 0x#{typeref.to_s(16)} typeval = #{typeval} len = #{len}")
+      me = VSStubs::VSArray.new(typeref,typeval)
+      (1..len).each do |i|
+        me.add(self.deserialize_value)
+      end
+      return me
+    end
+
+    def string_array(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSStubs::VSStringArray.new()
+      (1..len).each do |i|
+        str = self.read_string
+        me.add(str)
+        dlog(t,"string_array_elem: #{str}")
+      end
+      return me
+    end
+
+    def list(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSStubs::VSList.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value)
+      end
+      return me
+    end
+
+    def unit(t=nil)
+      s1 = read_double
+      s2 = read_int32
+      dlog(t,"#{s1.to_s(16).rjust(16,"0")},#{s2.to_s(16).rjust(8,"0")}")
+      VSStubs::VSUnit.new(s1,s2)
+    end
+
+    def indexed_string(t=nil)
+      str = self.read_string
+      @indexed_strings << str
+      dlog(t,"idx = #{@indexed_strings.size - 1} val = #{str}")
+      VSStubs::VSIndexedString.new(str)
+    end
+
+    def indexed_string_ref(t=nil)
+      ref = self.read_int
+      dlog(t,"ref = #{ref} val = #{@indexed_strings[ref]}")
+      VSStubs::VSIndexedStringRef.new(ref)
+    end
+
+    def string(t=nil)
+      str = self.read_string
+      dlog(t,str)
+      VSStubs::VSString.new(str)
+    end
+
+    # VSStubs::VSReadValue types
+    def color(t=nil)
+      val = self.read_int32
+      dlog(t,val.to_s(16))
+      VSStubs::VSColor.new(val)
+    end
+
+    def known_color(t=nil)
+      index = self.read_7bit_encoded_int
+      dlog(t,"index = #{index.to_s(16)}")
+      VSStubs::VSKnownColor.new(index)
+    end
+
+    def int16(t=nil)
+      val = read_short
+      dlog(t,val)
+      VSStubs::VSInt16.new(val)
+    end
+
+    def int32(t=nil)
+      val = self.read_7bit_encoded_int
+      dlog(t,val)
+      VSStubs::VSInt32.new(val)
+    end
+
+    def byte(t=nil)
+      val = self.read_byte
+      dlog(t,val)
+      VSStubs::VSByte.new(val)
+    end
+
+    def char(t=nil)
+      val = self.read_byte
+      dlog(t,val)
+      VSStubs::VSChar.new(val)
+    end
+
+    def date_time(t=nil)
+      val = self.read_double
+      dlog(t,val)
+      VSStubs::VSDateTime.new(val)
+    end
+
+    def double(t=nil)
+      val = self.read_double
+      dlog(t,val)
+      VSStubs::VSDouble.new(val)
+    end
+
+    def single(t=nil)
+      val = self.read_single
+      dlog(t,val)
+      VSStubs::VSSingle.new(val)
+  end
+
+    # VSStubs::VSValue types
+    def null(t=nil);        dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def empty_byte(t=nil);  dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def zeroint32(t=nil);   dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def bool_true(t=nil);   dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def bool_false(t=nil);  dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def empty_color(t=nil); dlog(t,nil); return VSStubs::VSValue.new(t); end
+    def empty_unit(t=nil);  dlog(t,nil); return VSStubs::VSValue.new(t); end
+
+    # deserialize_value
+    def deserialize_value
+      @last_offset = self.offset
+      token = self.read_byte # self.read_raw_byte
+      if not (tsym = VIEWSTATE_TYPES[token])
+        STDERR.puts "TOKEN: [0x#{token.to_s(16)}] at #{last_offset}"
+        STDERR.puts @bufarr.slice(0..31).join("").hexdump
+        raise "Invalid Type [0x#{token.to_s(16)}] at #{last_offset}" if not (tsym = VIEWSTATE_TYPES[token])
+      end
+      nobj = self.send(tsym,token)
+      raise "Invalid Class Returned #{nobj.class}" if not VIEWSTATE_TYPES.include?(nobj.opcode)
+      return nobj
+    end
+
+  end
+end

data/lib/wwmd/viewstate/viewstate_from_xml.rb

@@ -0,0 +1,128 @@
+module WWMD
+  class ViewState
+# directly serialize into stack from received xml (the easy way)
+# this is pretty silly but it didn't take me very long so...
+
+    attr_reader :xmlstack
+
+    def get_sym(str)
+      str.split(":").last.gsub(/[A-Z]+/,'\1_\0').downcase[1..-1].gsub(/\Avs/,"").to_sym
+    end
+
+    def opcode(name,val)
+      sym = get_sym(name)
+      if sym == :value
+        ret = VIEWSTATE_TYPES.index(val.to_sym)
+      else
+        ret = VIEWSTATE_TYPES.index(sym)
+      end
+      ret
+    end
+
+    def serialize_hashtable(node)
+      tstack = ""
+      tstack << self.write_7bit_encoded_int(node['size'].to_i)
+      node.children.each do |c|
+        next if c.text?
+        raise "Invalid Hashtable: got #{c.name}" if not c.name == "Pair"
+      end
+      tstack
+    end
+
+    def decode_text(node)
+      case node['encoding']
+        when "urlencoded"
+          node.inner_text.unescape
+        when "quoted-printable"
+          node.inner_text.from_qp
+        when "base64"
+          node.inner_text.b64d
+        when "hexify"
+          node.inner_text.dehexify
+        else
+          node.inner_text
+      end
+    end
+
+    def write_node(node)
+      return false if node.text?
+      tstack = ""
+      # this is a hack to get sparse_array to work
+      return false if ["Pair","Key","Value"].include?(node.name) # skip and fall through
+      if ["Index","Size","Elements"].include?(node.name)
+        @xmlstack << self.write_7bit_encoded_int(node.inner_text.to_i)
+        return false
+      end
+      if node.name == "Mac"
+        @xmlstack << decode_text(node)
+        return false
+      end
+      # end hack
+      flag = true # begin; sillyness; rescue => me; end
+      case get_sym(node.name)
+        when :pair, :triplet, :value, :sparse_array, :type, :string_formatted
+        when :int_enum, :known_color, :int32
+          tstack << self.write_7bit_encoded_int(node.inner_text.to_i)
+        when :int16
+          tstack << self.write_short(node.inner_text.to_i)
+        when :byte, :char, :indexed_string_ref
+          tstack << self.write_byte(node.inner_text.to_i)
+        when :color, :single
+          tstack << self.write_int32(node.inner_text.to_i)
+        when :double, :date_time
+          tstack << self.write_double(node.inner_text.to_i)
+        when :unit
+          tstack << self.write_double(node['dword'].to_i)
+          tstack << self.write_single(node['word'].to_i)
+        when :list, :string_array, :array
+          tstack << self.write_7bit_encoded_int(node['size'].to_i)
+        when :string, :indexed_string, :binary_serialized
+          flag = false if ([:string_array,:string_formatted].include?(get_sym(node.parent.name)))
+          # get encoding
+          str = decode_text(node)
+          tstack << self.write_7bit_encoded_int(str.size)
+          tstack << str
+        when :hashtable, :hybrid_dict
+          tstack << serialize_hashtable(node)
+        else
+          raise "Invalid Node:\n#{node.name}"
+      end
+
+      # [flag] is a hack to get around string_array and string_formatted emitting opcodes
+      @xmlstack << self.write_byte(opcode(node.name,node.inner_text)) if flag
+      if node.has_attribute?("typeref")
+        if node['typeref'].to_i == 0x2b
+          @xmlstack << self.serialize_type(node['typeref'].to_i,node['typeval'].to_i)
+        else
+          @xmlstack << self.serialize_type(node['typeref'].to_i,node['typeval'])
+        end
+      end
+      @xmlstack << tstack
+    end
+
+    def serialize_xml(node)
+      begin
+        write_node(node)
+      rescue => e
+        STDERR.puts "ERROR parsing node:\n#{node.to_s}"
+        raise e
+      end
+      node.children.each do |c|
+        serialize_xml(c)
+      end
+    end
+
+    def from_xml(xml)
+      @xmlstack = ""
+      doc = Nokogiri::XML.parse(xml)
+      root = doc.root
+      raise "Invalid ViewState Version" if not root.has_attribute?("version")
+      @xmlstack << root['version'].b64d
+      root.children.each do |c|
+        serialize_xml(c)
+      end
+      self.deserialize(@xmlstack.b64e)
+    end
+
+  end
+end