watobo 0.9.8.677

data/lib/watobo/mixins/request_parser.rb

@@ -0,0 +1,210 @@
+# .
+# request_parser.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Mixins
+    # This mixin can be used to parse a String or any object which supports method.to_s into a valid http request string
+    module RequestParser
+      # This method parses (eval) ruby code which is included in the string.
+      # Ruby code is identified by its surrounding delimiters - default: '%%'.
+      # For examples the string 'ABC%%"_"*10%%DEFG' will result to 'ABC__________DEFG'
+      #
+      # Possible prefs:
+      #
+      # :code_dlmtr [String] - set ruby code delimiter
+      def parse_code(prefs={})
+        cprefs = { :code_dlmtr => '%%' } # default delimiter for ruby code
+        cprefs.update(prefs)
+
+        pattern="(#{cprefs[:code_dlmtr]}.*?#{cprefs[:code_dlmtr]})"
+        request = self.to_s
+
+        begin
+          # puts new_request
+          expr = ''
+          new_request = ''
+          request.split(/\n/).each do |line|
+            #puts line.unpack("H*")
+            new_line = line
+            parsed_line = ''
+            pos = 0
+            off = 0
+            while pos >= 0 and pos < line.length
+              /#{pattern}/.match(line[pos..-1])
+              match = $1
+              break if match.nil?
+              #new_line = parsed_line
+              expr = match.gsub(/%%/,"")
+              puts "DEBUG: executing: #{expr}" if $DEBUG
+              result = eval(expr)
+              puts "DEBUG: got #{result.class}" if $DEBUG
+              if result.is_a? File
+                data = result.read
+                result.close
+
+              elsif result.is_a? String
+                data = result
+              elsif result.is_a? Array
+                data = result.join
+              else
+                log("!!!WATOBO - expression must return String or File !!!",'')
+              end
+              start = line.index(match)
+
+              parsed_line += line[off..start-1] if start > 0
+              parsed_line += data
+              pos = start + match.length
+              off = pos
+            end
+
+            unless parsed_line.empty?
+              parsed_line += line[off..-1]
+              new_request += "#{parsed_line}\n"
+            else
+              new_request += "#{new_line}\n"
+            end
+            #puts new_request
+          end
+
+          return new_request
+
+        rescue SyntaxError, LocalJumpError, NameError => e
+          raise SyntaxError, "SyntaxError in '#{expr}'"
+          #rescue LocalJumpError => e
+          #  raise LocalJumpError, "(#{expr}) LocalJumpError!"
+          #rescue NameError => e
+          #  raise NameError, "(#{expr}) NameError!"
+          #rescue => e
+          #  puts e
+          #  raise e, "(#{expr}) Not a valid expression!"
+        end
+
+        #   puts new_request
+        return nil
+
+      end
+
+      def unchunked( opts = {} )
+        options = { :update_content_length => false }
+        options.update opts
+        begin
+          text = parse_code
+          eoh = self.index("\n\n")
+          unless eoh.nil?
+            raw_header = text[0..eoh-1]
+            raw_body = text[eoh+1..-1]
+          else
+            raw_header = text
+            raw_body = nil
+          end
+
+          unchunked = raw_header.split("\n")
+          unchunked.extend Watobo::Mixin::Parser::Url
+          unchunked.extend Watobo::Mixin::Parser::Web10
+          unchunked.extend Watobo::Mixin::Shaper::Web10
+
+          unless raw_body.nil?
+            unchunked
+          end
+
+        rescue => bang
+        end
+      end
+
+      def to_request(opts={})
+        options = { :update_content_length => false }
+        options.update opts
+        begin
+          text = parse_code
+          result = []
+
+          if text =~ /\n\n/
+            dummy = text.split(/\n\n/)
+            header = dummy.shift.split(/\n/)
+            body = dummy.join("\n\n")
+          else
+            header = text.split(/\n/)
+            body = nil
+          end
+
+          header.each do |h|
+            result.push "#{h}\r\n"
+          end
+
+          result.extend Watobo::Mixin::Parser::Url
+          result.extend Watobo::Mixin::Parser::Web10
+          result.extend Watobo::Mixin::Shaper::Web10
+
+          ct = result.content_type
+          # last line is without "\r\n" if text has a body
+          if ct =~ /multipart\/form/ and body then
+            #Content-Type: multipart/form-data; boundary=---------------------------3035221901842
+            if ct =~ /boundary=([\-\w]+)/
+              boundary = $1.strip
+              chunks = body.split(boundary)
+              e = chunks.pop # remove "--"
+              new_body = []
+              chunks.each do |c|
+                new_chunk = ''
+                c.gsub!(/[\-]+$/,'')
+                next if c.nil?
+                next if c.strip.empty?
+                c.strip!
+                if c =~ /\n\n/
+                  ctmp = c.split(/\n\n/)
+                  cheader = ctmp.shift.split(/\n/)
+                  cbody = ctmp.join("\n\n")
+                else
+                  cheader = c.split(/\n/)
+                  cbody = nil
+                end
+                new_chunk = cheader.join("\r\n")
+                new_chunk +=  "\r\n\r\n"
+                new_chunk += cbody.strip + "\r\n" if cbody
+
+                # puts cbody
+                new_body.push new_chunk
+
+              end
+              body = "--#{boundary}\r\n"
+              body += new_body.join("--#{boundary}\r\n")
+              body += "--#{boundary}--"
+            end
+            #  body.gsub!(/\n/, "\r\n") if body
+
+          end
+
+          if body then
+            result.push "\r\n"
+            result.push body.strip
+          end
+
+          result.fixupContentLength() if options[:update_content_length] == true
+          return result
+        rescue
+          raise
+        end
+        #return nil
+      end
+
+    end
+  end
+end

data/lib/watobo/mixins/shapers.rb

@@ -0,0 +1,345 @@
+# .
+# shapers.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Mixin
+    module Shaper
+      module Web10
+        def replace_post_parm(parm,value)
+          parm_quoted = Regexp.quote(parm)
+          self.last.gsub!(/([?&]{0,1})#{parm_quoted}=([0-9a-zA-Z\-\._,+<>\%!=]*)(&{0,1})/i, "\\1#{parm}=#{value}\\3")
+        end
+
+        def replace_get_parm(parm,value)
+          parm_quoted = Regexp.quote(parm)
+          # puts "replacing parameter #{parm} with value #{value}"
+          # self.first.gsub!(/([?&]{0,1})#{parm}=([0-9a-zA-Z\-\._,+<>\%!=]*)(&{0,1})/i, "\\1#{parm}=#{value}\\3")
+          self.first.gsub!(/([?&]{1})#{parm_quoted}=([^ &]*)(&{0,1})/i, "\\1#{parm}=#{value}\\3")
+        end
+
+        def replaceMethod(new_method)
+          self.first.gsub!(/^[^[:space:]]{1,}/i, "#{new_method}")
+        end
+
+        def replaceFileExt(new_file)
+          #   puts "replace element #{new_element}"
+          begin
+            new_file.gsub!(/^\//, "")
+            self.first.gsub!(/([^\?]*\/)(.*) (HTTP.*)/i,"\\1#{new_file} \\3")
+          rescue => bang
+            puts bang
+          end
+        end
+
+        def replaceElement(new_element)
+          #   puts "replace element #{new_element}"
+          new_element.gsub!(/^\//, "")
+          self.first.gsub!(/(.*\/)(.*) (HTTP.*)/i,"\\1#{new_element} \\3")
+        end
+
+        def replaceURL(new_url)
+          self.first.gsub!(/(^[^[:space:]]{1,})(.*) (HTTP.*)/i,"\\1 #{new_url} \\3")
+        end
+
+        def replaceQuery(new_query)
+          new_query.gsub!(/^\//, "")
+          self.first.gsub!(/(.*\/)(.*) (HTTP.*)/i,"\\1#{new_query} \\3")
+        end
+
+        def strip_path()
+          if self.first =~ /(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}[^\?]*\/).* (HTTP.*)/i then
+            new_line = "#{$1} #{$2}"
+          self.shift
+          self.unshift(new_line)
+          end
+        # puts "* StripPath: #{self.first}"
+        end
+
+        def setDir(dir)
+          dir.strip!
+          dir.gsub!(/^\//,"")
+          dir.gsub!(/\/$/,"")
+          dir += "/" unless dir == ''
+          self.first.gsub!(/(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)(.*)( HTTP\/.*)/, "\\1#{dir}\\3")
+        end
+
+        def appendDir(dir)
+          dir.gsub!(/^\//,"")
+          self.first.gsub!(/(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}.*\/).*( HTTP\/.*)/, "\\1#{dir}\\2")
+
+        end
+
+        def add_post_parm(parm,value)
+          line = self.last
+          return false if line !~ /=/
+          line += "&#{parm}=#{value}"
+          self.pop
+          self.push line
+        end
+
+        def add_get_parm(parm,value)
+          line = self.shift
+          new_p = "&"
+          new_p = "?" if not self.element =~ /\?/
+          new_p += parm
+          line.gsub!(/( HTTP\/.*)/, "#{new_p}=#{value}\\1")
+          self.unshift(line)
+        end
+
+        def addHeader(header, value)
+          self_copy = []
+          self_copy.concat(self.headers)
+          self_copy.push "#{header}: #{value}\r\n"
+
+          unless self.body.nil?
+            self_copy.push "\r\n"
+          #self_copy.concat(self.body)
+          self_copy.push self.body
+          end
+
+          self.replace(self_copy)
+
+        end
+
+        def removeURI
+          if self.first =~ /(^[^[:space:]]{1,}) (https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/ then
+            uri = $2
+            self.first.gsub!(/(^[^[:space:]]{1,}) (#{Regexp.quote(uri)})/,"\\1 /")
+          # puts "* Removed URI: #{uri}"
+          # puts self.first
+          return uri
+          else
+            return nil
+          end
+        #self.first.gsub!(/^(.*)(https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/,"\\1/")
+        end
+
+        def removeBody
+          self.pop if self[-2].strip.empty?
+        end
+
+        def restoreURI(uri)
+          if self.first =~ /(^[^[:space:]]{1,}) \/(.*) (HTTP\/.*)/ then
+            method = $1
+            rest = $2
+            http = $3.strip
+            #self.first.gsub!(/^\w*/, "#{method} #{uri}#{rest}")
+            self.shift
+            self.unshift "#{method} #{uri}#{rest} #{http}\r\n"
+          return self.first
+          else
+            return nil
+          end
+        #self.first.gsub!(/^(.*)(https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/,"\\1/")
+        end
+
+        #
+        # R E M O V E _ H E A D E R
+        #
+
+        def removeHeader(header)
+          begin
+            eoh_index = self.length
+            eoh_index -= 1 unless self.body.nil?
+
+            self.delete_if {|x| self.index(x) <= eoh_index and x =~ /#{header}/i }
+          rescue => bang
+            puts bang
+            puts bang.backtrace if $DEBUG
+            puts self
+            puts "====="
+          end
+        end
+
+        # removeUrlParms
+        # Function: Remove all parameter within the URL
+        #
+        def removeUrlParms
+          line = self.shift
+          new_line = "#{line}"
+          # get end-of-path-index
+          eop_index = line.rindex(/[^ HTTP]\//)
+          # get start of parms
+          sop_index = line.index(/(\?|&)/, eop_index)
+          # find end-of-url
+          eou_index = line.index(/ HTTP/)
+
+          unless sop_index.nil?
+          new_line = line[0..sop_index-1]
+          new_line += line[eou_index..-1]
+          end
+
+          self.unshift new_line
+        end
+
+        def removeHeader_OLD(header)
+          #  p "REMOVE HEADER: #{header}"
+          begin
+            self_copy = []
+            eoh = false
+            self.each do |line|
+              puts self if line.nil?
+              if not eoh == true then
+                if not line =~ /#{header}/i
+                self_copy.push line unless line.nil?
+                end
+              else
+              self_copy.push line unless line.nil?
+              end
+
+              if line and line.strip.empty? then
+              eoh = true
+              end
+            end
+            self.replace(self_copy)
+
+          rescue => bang
+            puts bang
+            puts bang.backtrace if $DEBUG
+            puts self
+            puts "====="
+          end
+        end
+
+        def replace_header(header, value)
+
+        end
+
+        def fix_session(pattern,value)
+
+        end
+
+        def fix_content_length
+          return false if self.body.nil?
+          eoh_index = self.length - 2
+          self.map!{ |x|
+            x.gsub!(/^(Content-Length: )(\d+)/, "\\1#{self.body.length.to_s}") if self.index(x) <= eoh_index
+            x
+          }
+        end
+
+        def fixupContentLength
+          te = self.transferEncoding
+          if te == Watobo::TE_CHUNKED then
+            # puts "Transfer-Encoding = TE_CHUNKED"
+            # puts self.body
+            self.removeHeader("Transfer-Encoding")
+            self.addHeader("Content-Length", "0")
+            new = []
+            new.concat self.headers
+            new.push "\r\n"
+
+            bytes_to_read = 0
+            body = []
+            is_new_chunk = false
+
+            off = 0
+            new_body = ''
+
+            body_orig = self.body
+            puts body_orig.class
+            while body_orig[off..-1] =~ /^([0-9a-fA-F]{1,6})\r\n/
+              len_raw = "#{$1}"
+
+              len = len_raw.hex
+
+              chunk_start = off + len_raw.length + 2
+              chunk_end = chunk_start + len
+
+              break if len == 0
+
+              new_body.chomp!
+              new_body += "#{body_orig[chunk_start..chunk_end]}"
+
+              off = chunk_end + 2
+            end
+
+          new.push new_body
+          self.replace(new)
+          self.fix_content_length
+          # puts "= FIXED ="
+          # puts self.headers
+          elsif te == Watobo::TE_NONE then
+          self.fix_content_length
+          end
+
+        end
+
+        def setRawQueryParms(parm_string)
+          return nil if parm_string.nil?
+          return nil if parm_string == ''
+          new = ""
+          path = Regexp.quote(self.path)
+          #puts path
+          if self.first =~ /(.*#{path})/ then
+            new = $1 << "?" << parm_string
+          end
+          self.first.gsub!(/(.*) (HTTP\/.*)/, "#{new} \\2")
+        end
+
+        def appendQueryParms(parms)
+          return if parms.nil?
+          return if parms == ''
+
+          puts self.first
+          puts self.file_ext
+
+          pref = (self.file_ext =~ /\?/) ? '&' : '?'
+          puts "append query parms"
+          self.first.gsub!(/(.*) (HTTP\/.*)/, "\\1#{pref}#{parms} \\2")
+
+        end
+
+        def setCookie(cname="Cookie", value=nil)
+          return nil if value.nil?
+
+          self.map!{ |l|
+            break if l.strip.empty?
+            if l =~ /^#{cname}:/i
+              l = "#{cname}: #{value}"
+            end
+          }
+        end
+
+        # sets post data
+        def setData(data)
+          return if data.nil?
+          if self.has_body?
+          self.pop
+          self.push data
+          else
+            self.push("\r\n")
+          self.push data
+          end
+        end
+
+        def setMethod(method)
+          self.first.gsub!(/(^[^[:space:]]{1,}) /, "#{method} ")
+        end
+
+        def setHTTPVersion(version)
+          self.first.gsub!(/HTTP\/(.*)$/, "HTTP\/#{version}")
+        #  puts "HTTPVersion fixed: #{self.first}"
+        end
+      end
+    end
+  end
+end

data/lib/watobo/mixins/transcoders.rb

@@ -0,0 +1,88 @@
+# .
+# transcoders.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Mixin
+  module Transcoders
+    
+    def url_encode
+       CGI::escape(self)  
+    end
+    
+    def url_decode
+      CGI::unescape(self)
+    end
+    
+    
+    def b64decode
+      begin
+        b64string = self
+        rs = Base64.decode64(b64string)
+        return rs
+      rescue
+        return ""
+      end
+    end
+    
+    
+    def b64encode
+      begin
+        plain = self
+        rs = Base64.encode64(plain)
+        # we only need a simple string without linebreaks
+        rs.gsub!(/\n/,'')
+        rs.strip!
+        return rs
+      rescue
+        return ""
+      end
+    end
+    
+    def hex2int
+      begin
+        plain = self.strip
+        if plain =~ /^[0-9a-fA-F]{1,8}$/ then
+          return plain.hex
+        else
+          return ""
+        end
+      rescue
+        return ""
+      end
+    end
+    
+    def hexencode
+      begin
+        
+        
+     self.unpack("H*")[0]
+      rescue
+        return ""
+      end
+      
+    end
+    def hexdecode
+      
+      [ self ].pack("H*")
+    end
+  end
+  end
+end

data/lib/watobo/mixins.rb

@@ -0,0 +1,32 @@
+# .
+# mixins.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Mixins
+    mixins_path = File.expand_path(File.join(File.dirname(__FILE__), "mixins"))
+  # puts "* loading mixins #{mixins_path}"
+    Dir.glob("#{mixins_path}/*.rb").each do |cf|
+      puts "+ #{File.basename(cf)}" if $DEBUG
+      require File.join("watobo","mixins", File.basename(cf))
+
+    end
+  end
+end

data/lib/watobo/utils/check_regex.rb

@@ -0,0 +1,36 @@
+# .
+# check_regex.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Utils
+    def Utils.checkRegex(pattern)
+      begin
+        # use nice string to test pattern ;)
+        "watobo rocks!!!" =~ /#{pattern}/i
+        return true
+      rescue => bang
+       # puts bang
+        return false, bang
+      end
+    end
+    
+  end #--- Utils
+end #---Watobo