syspy 0.0.1 → 0.0.2

data/lib/bytes.rb

@@ -0,0 +1,98 @@
+require "bindata"
+
+module Syspy
+  class Bytes
+    def self.uint(io)       
+      BinData::Uint8.read(io).to_i        
+    end
+
+    def self.uintle(io,length)
+      case length
+        when 1:
+          BinData::Uint8.read(io).to_i
+        when 2:
+          BinData::Uint16le.read(io).to_i
+        when 4:
+          BinData::Uint32le.read(io).to_i
+        else
+          raise ArgumentError.new("Invalid length")
+      end
+    end
+
+    def self.uint16le(io)    
+      BinData::Uint16le.read(io).to_i
+    end
+    
+    def self.uint32le(io)
+      BinData::Uint32le.read(io) .to_i      
+    end
+
+    def self.uintbe(io,length)
+      case length
+        when 1:
+          BinData::Uint8.read(io).to_i
+        when 2:
+          BinData::Uint16be.read(io).to_i
+        when 4:
+          BinData::Uint32be.read(io).to_i
+        else
+          raise ArgumentError.new("Invalid length")
+      end
+    end
+   
+    def self.uint16be(io)    
+      BinData::Uint16be.read(io).to_i
+    end
+    
+    def self.uint32be(io)
+      BinData::Uint32be.read(io).to_i      
+    end
+
+    def self.int(io)
+      BinData::Int8.read(io).to_i
+    end
+
+    def self.intle(io,length)
+      case length
+        when 1:
+          BinData::Int8.read(io).to_i
+        when 2:
+          BinData::Int16le.read(io).to_i
+        when 4:
+          BinData::Int32le.read(io).to_i
+        else
+          raise ArgumentError.new("Invalid length")
+      end
+    end
+
+    def self.int16le(io)    
+      BinData::Int16le.read(io).to_i
+    end
+    
+    def self.int32le(io)
+      BinData::Int32le.read(io).to_i      
+    end
+    
+    def self.intbe(io,length)
+      case length
+        when 1:
+          BinData::Int8.read(io).to_i
+        when 2:
+          BinData::Int16be.read(io).to_i
+        when 4:
+          BinData::Int32be.read(io).to_i
+        else
+          raise ArgumentError.new("Invalid length")
+      end
+    end
+
+    def self.int16be(io)    
+      BinData::Int16be.read(io).to_i
+    end
+    
+    def self.int32be(io)
+      BinData::Int32be.read(io).to_i       
+    end 
+
+  end
+end

data/lib/log.rb

@@ -0,0 +1,45 @@
+require "logger"
+
+module Syspy
+  class Log
+
+    LOG_FILE = "syspy.log"
+    LOGGERS = []
+    
+    STDOUT_LOG = Logger.new(STDOUT)
+    STDOUT_LOG.level = Logger::INFO
+
+    #FILE_LOG = Logger.new(LOG_FILE)
+    #FILE_LOG.level = Logger::INFO
+
+    LOGGERS << STDOUT_LOG
+    #LOGGERS << FILE_LOG
+    
+    def self.fatal(message)
+      self.log(Logger::FATAL,message)
+    end
+
+    def self.error(message)
+      self.log(Logger::ERROR,message)
+    end
+
+    def self.warn(message)
+      self.log(Logger::WARN,message)
+    end
+
+    def self.info(message)
+      self.log(Logger::INFO,message)
+    end
+
+    def self.debug(message)
+      self.log(Logger::DEBUG,message)
+    end
+
+    def self.log(severity,message) 
+      LOGGERS.each(){|logger|
+        logger.log(severity,message)
+      } 
+    end
+    
+  end
+end

data/lib/tds_package.rb

@@ -0,0 +1,39 @@
+require "lib/bytes"
+
+module Syspy
+  
+  class ParseError < Exception
+  end
+
+  class TdsPackage
+    
+    def read_uint(io)
+      Bytes.uint(io)
+    end
+
+    def read_uint32(io)
+      Bytes.uint32le(io)
+    end
+
+    def read_uint16(io)
+      Bytes.uint16le(io)
+    end
+
+    def read_int(io)
+      Bytes.int(io)
+    end
+
+    def read_int32(io)
+       Bytes.int32le(io)
+    end
+
+    def read_int16(io)
+      Bytes.int16le(io)
+    end
+
+    def read_text(io,length)
+      io.read(length)
+    end
+
+  end
+end

data/lib/tds_package_stream.rb

@@ -0,0 +1,121 @@
+require "stringio"
+require "thread"
+
+require "lib/tds_types"
+require "lib/tds_tokens"
+
+module Syspy
+  class TdsPackageStream
+
+    def initialize(interface,dst,dst_port)
+      @interface = interface
+      @dst = dst
+      @dst_port = dst_port
+      @in,@out = IO.pipe()
+    end
+
+    def each_package()
+      Thread.abort_on_exception = true       
+      @tcpdump_thread = Thread.new(){       
+        IO.popen("tcpdump -q -y EN10MB -U -B #{1024 * 1024} -w - -i #{@interface} tcp and dst #{@dst} and dst port #{@dst_port} 2>/dev/null"){|io|         
+          content = ""
+          loop(){
+            tcp_length = read_ip_header(io)
+            Log.debug "Got IP package: #{tcp_length}"
+            content_length = read_tcp_header(io,tcp_length)
+            Log.debug "Got TCP package: #{content_length}"
+            
+            if(content_length > 0)        
+              content = io.read(content_length)       
+              @out.write(content)
+              @out.flush      
+            end
+
+            Log.debug "Network package done"      
+          } 
+        }
+      }  
+
+      content = ""
+      @in.each_byte(){|byte|
+        if(byte == 0x0F)                 
+          last_packet_indicator = Bytes.uint(@in)          
+          length = Bytes.uint16be(@in)
+           
+          # skip next 4 bytes of the header
+          if(Bytes.uint32be(@in) == 0x00)
+            content << @in.read(length - 8)
+            
+            if(last_packet_indicator == 0x1)              
+              begin
+                io = StringIO.new(content)
+                package = handle_package(io)
+                yield package if package               
+              ensure
+                content = ""
+              end             
+            end
+          end
+        end           
+      }     
+    end
+
+    def handle_package(io)    
+      token = io.readchar()
+      token_class = TdsTokens.token_class(token)
+      if(token_class)
+        length = TdsTokens.fixed_length(token)
+        unless(length)
+          length_field_size = TdsTokens.length_field_size(token)
+          if(length_field_size)
+            length = Bytes.uintle(io,length_field_size)
+          end       
+        end
+        Log.debug("Got #{TdsTokens.token_name(token)} of #{length} bytes")
+        package = token_class.new(io,length)
+        return package        
+      end
+      nil   
+    end
+
+    def read_ip_header(io)
+      count = 0
+      loop(){
+        network_type = Bytes.uint16be(io)
+        break if network_type == 0x800 and count >= 14
+        count += 1 
+      }    
+
+      # read IP version and header length
+      ver_len = io.readchar()
+      version = ver_len >> 4
+       
+      raise "Invalid IP version: #{version}" unless version == 4 || version == 6
+
+      header_length = (ver_len & 0x0F) * 4
+       
+      # skip TOS
+      io.readchar()
+       
+      # get package length
+      content_length = Bytes.uint16be(io)
+
+      # consume remaining IP header
+      io.read(header_length - 4)
+      content_length - header_length
+    end
+
+    def read_tcp_header(io, ip_package_size)
+      # skip first 12
+      io.read(12)
+
+      # get header length
+      tcp_offset = (io.readchar() >> 4) * 4
+       
+      # consume remaining tcp header
+      io.read(tcp_offset - 13)
+      
+      ip_package_size - tcp_offset
+    end  
+  end
+end

data/lib/tds_packages/tds_language.rb

@@ -0,0 +1,32 @@
+require "lib/tds_package" 
+
+module Syspy
+  class TdsLanguage < TdsPackage
+    
+    attr_reader :status, :language_text, :tds_paramfmt, :tds_params
+    
+    STATUS_PARAMETERIZED = 0x01
+
+    def initialize(io,length)
+      @status = read_uint(io)        
+      @language_text = read_text(io,length - 1)     
+      if(@status == 1 && !io.eof?)
+        token = read_uint(io)
+        if(token == TdsTokens::TDS_PARAMFMT || token == TdsTokens::TDS_PARAMFMT2)
+          paramfmt_length = Bytes.uintle(io,TdsTokens.length_field_size(token))
+          if(paramfmt_length < 1000000)          
+          @tds_paramfmt = TdsTokens.token_class(token).new(io,paramfmt_length)
+          if(@tds_paramfmt.params_count > 0)
+            token = read_uint(io)
+            if(token == TdsTokens::TDS_PARAMS)
+              @tds_params = TdsParams.new(io,@tds_paramfmt)
+            end
+          end
+          else
+            Log.warn("Illegal paramfmt length: #{paramfmt_length}")
+          end          
+        end
+      end      
+    end
+  end
+end

data/lib/tds_packages/tds_paramfmt.rb

@@ -0,0 +1,15 @@
+module Syspy
+  class TdsParamfmt < TdsPackage
+    
+    attr_reader :params_count, :parameters
+
+    def initialize(io,length)
+      @params_count = read_uint16(io)
+      puts "TdsParamfmt2: #{@params_count}"
+      @parameters = []
+      1.upto(@params_count){
+        
+      }
+    end
+  end
+end

data/lib/tds_packages/tds_paramfmt2.rb

@@ -0,0 +1,50 @@
+module Syspy
+  class TdsParamfmt2 < TdsPackage
+    
+    attr_reader :params_count, :parameters
+
+    def initialize(io,length)
+      @params_count = read_uint16(io)     
+      @parameters = []
+     
+      1.upto(@params_count){
+        parameter = {}
+        name_length = read_uint(io)
+        parameter[:name_length] = name_length
+        if(name_length > 0)
+          parameter[:param_name] = read_text(io,name_length)
+        end
+        parameter[:status] = read_uint32(io)
+        parameter[:user_type] = read_int32(io)
+        data_type = read_uint(io)
+        parameter[:data_type] = data_type        
+
+        data_length = TdsTypes.fixed_length(data_type)         
+
+        if(data_length == -5)
+          data_length = Bytes.int32le(io)
+        elsif(data_length == -4)
+          data_length = Bytes.int32le(io)
+        elsif(data_length == -2)
+          data_length = Bytes.int32le(io)
+        elsif(data_length == -1)
+           data_length = Bytes.uint(io) 
+        end       
+        
+        parameter[:length] = data_length
+
+        if(TdsTypes.numeric?(data_type))
+          parameter[:precision] = read_uint(io)
+          parameter[:scale] = read_uint(io)
+        end
+
+        locale_length = read_uint(io)
+        parameter[:locale_length] = locale_length
+        if(locale_length > 0)
+          parameter[:locale_info] = read_text(io,locale_length)
+        end       
+        @parameters << parameter
+      }     
+    end
+  end
+end

data/lib/tds_packages/tds_params.rb

@@ -0,0 +1,70 @@
+module Syspy
+  class TdsParams < TdsPackage
+    
+    attr_reader :params_count, :parameters
+
+    def initialize(io,paramfmt)
+      @parameters = []
+      paramfmt.parameters.each(){|format|
+        @parameters << read_data(io,format)
+      }          
+    end
+
+    def read_data(io,format)
+      data_type = format[:data_type]
+      case data_type
+        when TdsTypes::SYBINTN
+          len = read_int(io)                          
+          return Bytes.intle(io,len)
+        when TdsTypes::SYBINT1
+          return Bytes.int(io)
+        when TdsTypes::SYBINT2
+          return Bytes::int16le(io)
+        when TdsTypes::SYBINT4
+          return Bytes::int32le(io)
+        when TdsTypes::SYBCHAR, TdsTypes::SYBVARCHAR
+          len = read_uint(io)         
+          if (len > 0)
+             val = read_text(io,len)
+            # In TDS 4/5 zero length varchars are stored as a
+            # single space to distinguish them from nulls.
+            if(len == 1 && data_type == TdsTypes::SYBVARCHAR)
+              return " " == val ? "" : val     
+            end              
+            return val
+          end
+        when TdsTypes::SYBDATETIME4, TdsTypes::SYBDATETIMN, TdsTypes::SYBDATETIME
+          read_datetime(io,data_type)
+        else
+          raise "Unhandled data type: #{TdsTypes.name(data_type)} (0x#{data_type.to_s(16)})"
+      end
+    end
+
+    TIME_DIFF = Time.at(0) - Time.local(1900,1,1)
+
+    def read_datetime(io,data_type)
+      if (data_type == TdsTypes::SYBDATETIMN)
+        len = read_uint(io)
+      elsif (data_type == TdsTypes::SYBDATETIME4)
+        len = 4;
+      else 
+        len = 8;
+      end
+      
+      gmt_offset = Time.new().gmt_offset
+
+      case len
+        when 0
+          return nil
+        when 8
+          days = read_int32(io)
+          time = read_int32(io)
+          return Time.at(days  * 24 * 3600 - TIME_DIFF + time / 300 - gmt_offset)
+        when 4
+          days = read_int16le(io)
+          time = read_int16le(io)
+          return Time.at(days * 24 * 3600 + time * 60 - gmt_offset)
+      end
+    end
+  end
+end

data/lib/tds_tokens.rb

@@ -0,0 +1,104 @@
+module Syspy
+  class TdsTokens
+    TOKENS = [   
+      ["TDS_ALTFMT", 0xA8, 2],
+      ["TDS_ALTNAME", 0xA7, 2],
+      ["TDS_ALTROW", 0xD3, nil],
+      ["TDS_CAPABILITY", 0xE2, 2], 
+      ["TDS_COLINFO", 0xA5, 2],
+      ["TDS_COLINFO2", 0x20, 4],
+      ["TDS_CONTROL", 0xAE, 2],
+      ["TDS_CURCLOSE", 0x80, 2],
+      ["TDS_CURDECLARE", 0x86, 2],
+      ["TDS_CURDECLARE2", 0x23, 4],
+      ["TDS_CURDECLARE3", 0x10, 4],
+      ["TDS_CURDELETE", 0x81, 2],
+      ["TDS_CURFETCH", 0x82, 2],
+      ["TDS_CURINFO", 0x83, 2],
+      ["TDS_CURINFO2", 0x87, 2],
+      ["TDS_CURINFO3", 0x88, 2],
+      ["TDS_CUROPEN", 0x84, 2],
+      ["TDS_CURUPDATE", 0x85, 2],
+      ["TDS_DBRPC", 0xE6, 2],
+      ["TDS_DBRPC2", 0xE8, 2],
+      ["TDS_DONE", 0xFD, [8]],
+      ["TDS_DONEINPROC", 0xFF, [8]],
+      ["TDS_DONEPROC", 0xFE, [8]],
+      ["TDS_DYNAMIC", 0xE7, 2],
+      ["TDS_DYNAMIC2", 0x62, 4],
+      ["TDS_EED", 0xE5, 2],
+      ["TDS_ENVCHANGE", 0xE3, 2],
+      ["TDS_ERROR", 0xAA, 2],
+      ["TDS_EVENTNOTICE", 0xA2, 2],
+      ["TDS_INFO", 0xAB, 2],
+      ["TDS_KEY", 0xCA, nil],
+      ["TDS_LANGUAGE", 0x21, 4],
+      ["TDS_LOGINACK", 0xAD, 2],
+      ["TDS_LOGOUT", 0x71, [1]],
+      ["TDS_MSG", 0x65, 1, 1],
+      ["TDS_OFFSET", 0x78, [4]],
+      ["TDS_OPTIONCMD", 0xA6, 2],
+      ["TDS_ORDERBY", 0xA9, 2],
+      ["TDS_ORDERBY2", 0x22, 4],
+      ["TDS_PARAMFMT", 0xEC, 2],
+      ["TDS_PARAMFMT2", 0x20, 4],
+      ["TDS_PARAMS", 0xD7, nil],
+      ["TDS_RETURNSTATUS", 0x79, [4]],
+      ["TDS_RETURNVALUE", 0xAC, 2],
+      ["TDS_ROW", 0xD1, nil],
+      ["TDS_ROWFMT", 0xEE, 2],
+      ["TDS_ROWFMT2", 0x61, 4],
+      ["TDS_TABNAME", 0xA4, 2]
+    ]
+
+    NAMES = {}
+    FIXED_LENGTHS = {}
+    LENGTH_FIELD_SIZES = {}
+    STREAM_CLASSES = {}
+
+    TOKENS.each(){|values|
+      name = values[0]
+      token = values[1]
+      length = values[2]
+
+      self.const_set(name,token)
+
+      NAMES[token] = name
+      if(length)
+        if(length.instance_of?(Array))
+          FIXED_LENGTHS[token] = length.first
+        else
+          LENGTH_FIELD_SIZES[token] = length
+        end
+      end  
+        
+      class_file_name = name.downcase       
+      if(File.exist?("lib/tds_packages/#{class_file_name}.rb"))
+        require "lib/tds_packages/#{class_file_name}"
+        class_name =  class_file_name.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+        cl = eval(class_name)
+        STREAM_CLASSES[token] = cl
+      end
+    }
+
+    def self.token?(token)
+      NAMES.include?(token)
+    end
+
+    def self.token_name(token)
+      NAMES[token]
+    end
+
+    def self.token_class(token)
+      STREAM_CLASSES[token]
+    end
+
+    def self.fixed_length(token)
+      FIXED_LENGTHS[token]
+    end
+
+    def self.length_field_size(token)
+      LENGTH_FIELD_SIZES[token]
+    end    
+  end
+end

data/lib/tds_types.rb

@@ -0,0 +1,94 @@
+module Syspy
+  class TdsTypes
+    TYPES = [
+      [0x2f, "SYBCHAR"         , "char"             , -1, -1,    1, false, false, String          ],
+      [0x27, "SYBVARCHAR"      , "varchar"          , -1, -1,    1, false, false, String          ],
+      [0x26, "SYBINTN"         , "int"              , -1, 10,   11, true , false, Integer         ],
+      [0x30, "SYBINT1"         , "tinyint"          ,  1,  3,    4, false, false, Integer         ],
+      [0x34, "SYBINT2"         , "smallint"         ,  2,  5,    6, true , false, Integer         ],
+      [0x38, "SYBINT4"         , "int"              ,  4, 10,   11, true , false, Integer         ],
+      [0x7f, "SYBINT8"         , "bigint"           ,  8, 19,   20, true , false, Integer         ],
+      [0x3e, "SYBFLT8"         , "float"            ,  8, 15,   24, true , false, Float           ],
+      [0x3d, "SYBDATETIME"     , "datetime"         ,  8, 23,   23, false, false, Time            ],
+      [0x32, "SYBBIT"          , "bit"              ,  1,  1,    1, false, false, Integer         ],
+      [0x23, "SYBTEXT"         , "text"             , -4, -1,   -1, false, true , String          ],
+      [0x63, "SYBNTEXT"        , "ntext"            , -4, -1,   -1, false, true , String          ],
+      [0xae, "SYBUNITEXT"      , "unitext"          , -4, -1,   -1, false, true , String          ],
+      [0x22, "SYBIMAGE"        , "image"            , -4, -1,   -1, false, false, String          ],
+      [0x7a, "SYBMONEY4"       , "smallmoney"       ,  4, 10,   12, true , false, Integer         ],
+      [0x3c, "SYBMONEY"        , "money"            ,  8, 19,   21, true , false, Integer         ],
+      [0x31, "SYBDATETIME4"    , "smalldatetime"    ,  4, 16,   19, false, false, Time            ],
+      [0x3b, "SYBREAL"         , "real"             ,  4,  7,   14, true , false, Integer         ],
+      [0x2d, "SYBBINARY"       , "binary"           , -1, -1,    2, false, false, String          ],
+      [0x1f, "SYBVOID"         , "void"             , -1,  1,    1, false, false, nil             ],
+      [0x25, "SYBVARBINARY"    , "varbinary"        , -1, -1,   -1, false, false, String          ],
+      [0xa7, "SYBNVARCHAR"     , "nvarchar"         , -1, -1,   -1, false, false, String          ],
+      [0x68, "SYBBITN"         , "bit"              , -1,  1,    1, false, false, Integer         ],
+      [0x6c, "SYBNUMERIC"      , "numeric"          , -1, -1,   -1, true , false, Integer         ],
+      [0x61, "SYBDECIMAL"      , "decimal"          , -1, -1,   -1, true , false, Integer         ],
+      [0x6d, "SYBFLTN"         , "float"            , -1, 15,   24, true , false, Float           ],
+      [0x6e, "SYBMONEYN"       , "money"            , -1, 19,   21, true , false, Integer         ],
+      [0x6f, "SYBDATETIMN"     , "datetime"         , -1, 23,   23, false, false, Time            ],
+      [0x31, "SYBDATE"         , "date"             ,  4, 10,   10, false, false, Time            ],
+      [0x33, "SYBTIME"         , "time"             ,  4,  8,    8, false, false, Time            ],
+      [0x7b, "SYBDATEN"        , "date"             , -1, 10,   10, false, false, Time            ],
+      [0x93, "SYBTIMEN"        , "time"             , -1,  8,    8, false, false, Time            ],
+      [0xaf, "XSYBCHAR"        , "char"             , -2, -1,   -1, false, true , String          ],
+      [0xa7, "XSYBVARCHAR"     , "varchar"          , -2, -1,   -1, false, true , String          ],
+      [0xe7, "XSYBNVARCHAR"    , "nvarchar"         , -2, -1,   -1, false, true , String          ],
+      [0xef, "XSYBNCHAR"       , "nchar"            , -2, -1,   -1, false, true , String          ],
+      [0xa5, "XSYBVARBINARY"   , "varbinary"        , -2, -1,   -1, false, false, String          ],
+      [0xad, "XSYBBINARY"      , "binary"           , -2, -1,   -1, false, false, String          ],
+      [0xe1, "SYBLONGBINARY"   , "varbinary"        , -5, -1,    2, false, false, String          ],
+      [0x40, "SYBSINT1"        , "tinyint"          ,  1,  2,    3, false, false, Integer         ],
+      [0x41, "SYBUINT2"        , "unsigned smallint",  2,  5,    6, false, false, Integer         ],
+      [0x42, "SYBUINT4"        , "unsigned int"     ,  4, 10,   11, false, false, Integer         ],
+      [0x43, "SYBUINT8"        , "unsigned bigint"  ,  8, 20,   20, false, false, Integer         ],
+      [0x44, "SYBUINTN"        , "unsigned int"     , -1, 10,   11, true , false, Integer         ],
+      [0x24, "SYBUNIQUE"       , "uniqueidentifier" , -1, 36,   36, false, false, String          ],
+      [0x62, "SYBVARIANT"      , "sql_variant"      , -5,  0, 8000, false, false, String          ],
+      [0xbf, "SYBSINT8"        , "bigint"           ,  8, 19,   20, true , false, Integer         ],     
+      [0xf1, "XML"             , "xml"              , -4, -1,   -1, false, true , String          ]
+    ]
+
+    NAMES = {}
+    RUBY_TYPES = {}
+    FIXED_LENGTHS = {}
+    SIGNED = {}
+
+    TYPES.each(){|type|
+      code = type[0]
+      name = type[1]
+      length = type[3]
+      signed = type[6]
+      ruby_type = type[8]
+
+      const_set(name,code)
+    
+      NAMES[code] = name
+      FIXED_LENGTHS[code] = length
+      SIGNED[code] = signed
+      RUBY_TYPES[code] = ruby_type
+    }
+
+    def self.name(code)
+      NAMES[code]
+    end
+
+    def self.numeric?(code)
+     code == SYBNUMERIC || code == SYBDECIMAL
+    end
+    
+    def self.fixed_length(code)
+      FIXED_LENGTHS[code]
+    end
+
+    def self.signed?(code)
+      SIGNED[code]
+    end
+
+    def self.ruby_type(code)
+      RUBY_TYPES[code]
+    end
+  end
+end

data/syspy.rb

@@ -0,0 +1,63 @@
+require "rubygems"
+require "lib/log"
+require "lib/tds_package_stream"
+require "time"
+
+
+module Syspy
+  if(__FILE__ == $0)
+    if(ARGV.size != 3)
+      puts "Usage: sudo ruby syspy.rb <interface> <destination_ip> <destination_port>"
+      exit(1)
+    end
+      
+    if(`id -u`.strip != "0")
+      puts "Has to be run as root"
+      exit(2)
+    end
+
+    INTERFACE = ARGV[0]
+    DST = ARGV[1]
+    DST_PORT = ARGV[2]
+
+    # INTERFACE = "eth0"
+    # DST = "192.168.1.6"
+    # DST_PORT = "2048"    
+
+    stream = TdsPackageStream.new(INTERFACE,DST,DST_PORT)
+    stream.each_package(){|package|
+      if(package.instance_of?(TdsLanguage))
+        statement = package.language_text
+        replaced_statement = "#{statement}"
+        
+        index = 0
+        if(package.tds_params)
+          params = package.tds_params.parameters      
+          statement.scan(/@sql\d+[^ ]+/){|match|
+            param = params[index]
+            if(param.instance_of?(String))
+              replaced_statement.gsub!(match,"\"#{param}\"")
+            elsif(param.kind_of?(Numeric))
+              replaced_statement.gsub!(match,param.to_s)
+            elsif(param.instance_of?(Time))
+              replaced_statement.gsub!(match,"\"#{param.strftime("%Y%m%d %H:%M:%S")}\"")                    
+            end
+            index += 1
+          }
+        end
+        Log.info("Replaced parameters: #{index}\n\n#{replaced_statement.gsub("\n","\r\n")}\n------------------------------------------------------")   
+      end
+    }
+  end
+end  
+  
+ 
+
+
+
+
+
+
+
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: syspy
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Matthias Balmer
@@ -40,6 +40,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- syspy.rb
+- lib/bytes.rb
+- lib/tds_types.rb
+- lib/tds_tokens.rb
+- lib/tds_package_stream.rb
+- lib/tds_packages/tds_paramfmt2.rb
+- lib/tds_packages/tds_params.rb
+- lib/tds_packages/tds_paramfmt.rb
+- lib/tds_packages/tds_language.rb
+- lib/log.rb
+- lib/tds_package.rb
 - bin/syspy
 homepage: 
 licenses: []