network-utility 1.1.4

data/utility/ipv4_address.rb

@@ -0,0 +1,266 @@
+#coding:utf-8
+
+=begin # How To Use
+  ip,mask = IP.v4('10.37.214.42/17')
+  net = ip.network_with(mask)
+  p ip.to_b, mask.to_b, net.to_b
+  p ip.is_mask?, mask.is_mask?, net.is_network_with?(mask)
+  si,ei = ip.range_with(mask)
+  p si.to_d, ei.to_d, si.to_b, ei.to_b
+  
+  a = IP.v4('10.37.214.21/8')[0]
+  b = IP.v4('145.217.33.14/16')[0]
+  c = IP.v4('221.25.43.72/24')[0]
+  d = IP.v4('238.13.189.51')
+  e = IP.v4('246.211.74.63')
+  p a.is_class_a?, b.is_class_b?, c.is_class_c?, d.is_class_d?, e.is_class_e?
+  p a.is_private?, b.is_private?
+=end
+
+class IPv4
+  attr_reader :numbers,:number
+  
+  def mode string
+    if ['0b','0x','0d'].include?(string[0..1])
+      return string[2..-1],string[0..1]
+    else
+      return string,'0d'
+    end
+  end
+
+  def formmat string,mode
+    string.split('.').collect{|num|eval("#{mode}#{num}")}
+  end
+
+  def check num
+    return (0<=num && num<=255) ? true : false
+  end
+  
+  def checks nums
+    each = eval(nums.collect{|num|check(num).to_s}.join(' && '))
+    all = (nums.size == 4)
+    return each && all
+  end
+  
+  def generate string
+    (warn "Abnormal formmat string #{string}!";return nil) unless /[0b|0d|0x]?(\d+)\.(\d+)\.(\d+)\.(\d+)/.match(string)
+    @content,@mode = mode(string)
+    fours = formmat(@content,@mode)
+    if checks(fours)
+      @numbers = fours.clone
+      @number = eval("0b"+to_b.gsub('.',''))
+    else
+      warn "Abnormal decimal string #{string}!";return nil
+    end
+    return self
+  end
+  
+  def initialize string
+    generate string
+  end
+  
+  #### performance ####
+  def to_a
+    @numbers
+  end
+
+  def to_d
+    @numbers.collect{|n|n.to_s(10)}.join"."
+  end
+  
+  def to_h
+    @numbers.collect{|n|"%02x"%n}.join"."
+  end
+  
+  def to_b
+    @numbers.collect{|n|"%08b"%n}.join"."
+  end
+
+  def to_s # s = short
+    to_d
+  end
+  
+  def + num
+    @number += num
+    generate("0b"+("%032b"%@number).unpack("a8a8a8a8").join("."))
+  end
+  
+  def - num
+    @number -= num
+    generate("0b"+("%032b"%@number).unpack("a8a8a8a8").join("."))
+  end
+  
+  def is_class_a?
+    first =IPv4.new('10.0.0.0').number
+    last = IPv4.new('126.255.255.255').number
+    (first..last).include?(@number)
+  end
+  
+  def is_class_b?
+    first =IPv4.new('128.1.0.0').number
+    last = IPv4.new('191.255.255.255').number
+    (first..last).include?(@number)
+  end
+  
+  def is_class_c?
+    first =IPv4.new('192.0.1.0').number
+    last = IPv4.new('223.255.255.255').number
+    (first..last).include?(@number)
+  end
+  
+  def is_class_d?
+    first =IPv4.new('224.0.0.0').number
+    last = IPv4.new('239.255.255.255').number
+    (first..last).include?(@number)
+  end
+  
+  def is_class_e?
+    first =IPv4.new('240.0.0.0').number
+    last = IPv4.new('255.255.255.254').number
+    (first..last).include?(@number)
+  end
+  
+  def is_private?
+    fpa =IPv4.new('10.0.0.0').number
+    lpa = IPv4.new('10.255.255.255').number
+    fpb =IPv4.new('172.16.0.0').number
+    lpb = IPv4.new('172.31.255.255').number
+    fpc =IPv4.new('192.168.0.0').number
+    lpc = IPv4.new('192.168.255.255').number
+    (fpa..lpa).include?(@number) || (fpb..lpb).include?(@number) ||
+    (fpc..lpc).include?(@number)
+  end
+  
+  def is_another?
+    [IPv4.new('127.0.0.1').number, IPv4.new('255.255.255.255').number,
+     IPv4.new('0.0.0.0').number].include?(@number)
+  end
+  
+  #### mask ####
+  def mask_counter
+    if is_mask?
+      counter,msk = 0,to_b.gsub('.','')
+      while msk[-1]=='0'; counter += 1; msk = msk[0..-2]; end
+      return 32-counter
+    else
+      return nil
+    end
+  end
+  
+  def anti_mask_counter
+    if is_anti_mask?
+      counter,msk = 0,to_b.gsub('.','')
+      while msk[-1]=='1'; counter += 1; msk = msk[0..-2]; end
+      return counter
+    else
+      return nil
+    end
+  end
+  
+  def anti_mask
+    if (counter = mask_counter)
+      IPv4Mask.anti_number(counter)
+    else
+      warn "Not a net mask #{self}!";nil
+    end
+  end
+  
+  def mask
+    if (counter = anti_mask_counter)
+      IPv4Mask.number(counter)
+    else
+      warn "Not an anti-mask #{self}!";nil
+    end
+  end
+  
+  def is_mask?
+    !to_b.gsub('.','').include?('01')
+  end
+  
+  def is_anti_mask?
+    !to_b.gsub('.','').include?('10')
+  end
+  
+  #### network ####
+  def network_with mask
+    numbers = []
+    mask.numbers.each_with_index do|num,index|
+      numbers << (num & @numbers[index]).to_s
+    end
+    IPv4.new(numbers.join('.'))
+  end
+  
+  def range_with mask
+    return self, self if mask.mask_counter.to_i == 32
+    net = network_with(mask)
+    (start_ip = net.clone) + 1
+    (end_ip = net.clone) + (2**(32-mask.mask_counter.to_i) - 1)
+    return start_ip,end_ip
+  end
+  
+  def is_network_with? mask
+    msk_counter,msk = 0,mask.to_b.gsub('.','')
+    while msk[-1]=='0'
+      msk_counter += 1
+      msk = msk[0..-2]
+    end
+    nt_counter,nt = 0,to_b.gsub('.','')
+    while nt[-1]=='0'
+      nt_counter += 1
+      nt = nt[0..-2]
+    end
+    return (nt_counter >= msk_counter) ? true : false
+  end
+
+  def prefix_with another_ip
+    ip1 = self.to_b.gsub('.','')
+    ip2 = another_ip.to_b.gsub('.','')
+    count = 0
+    count += 1 while ip1[count] == ip2[count] && count < 32
+    return count
+  end
+end
+
+class IPv4Mask
+  def self.number num
+    str = "0b"+("1"*num+"0"*(32-num)).unpack("a8a8a8a8").join(".")
+    IPv4.new(str)
+  end
+  
+  def self.string str
+    temp = IPv4.new(str)
+    unless temp.is_mask?
+      raise "Invalid net mask #{str}!"
+      return nil
+    else
+      return temp
+    end
+  end
+  
+  def self.anti_number num
+    str = "0b"+("0"*num+"1"*(32-num)).unpack("a8a8a8a8").join(".")
+    IPv4.new(str)
+  end
+  
+  def self.anti_string str
+    temp = IPv4.new(str)
+    unless temp.is_anti_mask?
+      raise "Invalid anti mask #{str}!"
+      return nil
+    else
+      return temp
+    end
+  end
+end
+
+module IP
+  def self.v4 string
+    ip,msk = string.split("/")
+    unless msk
+      return IPv4.new(ip)
+    else
+      mask = msk.include?('.') ? IPv4Mask.string(msk) : IPv4Mask.number(msk.to_i)
+      return IPv4.new(ip),mask
+    end
+  end
+end

data/utility/ipv6_address.rb

@@ -0,0 +1,201 @@
+#coding:utf-8
+
+class IPv6
+  attr_reader :numbers,:number
+  
+  def mode string
+    return IPAddr.new(string).to_string,"0x"
+  end
+  
+  def formmat string,mode='0x'
+    string.split(':').collect{|num|eval("#{mode}#{num}")}
+  end
+  
+  def check num
+    return (0<= num && num <=0xffff) ? true : false
+  end
+  
+  def checks nums
+    each = eval(nums.collect{|num|check(num).to_s}.join(' && '))
+    all = (nums.size == 8)
+    return each && all
+  end
+
+  def generate string
+    (raise "Abnormal formmat string #{string}!";return nil) unless /[0b|0d|0x]?[a-f|A-F|0-9|\:]*/.match(string)
+    @content,@mode = mode(string)
+    eights = formmat(@content,@mode)
+    if checks(eights)
+      @numbers = eights.clone
+      @number = eval("0b"+to_b.gsub(':',''))
+    else
+      raise "Abnormal decimal string #{string}!";return nil
+    end
+    # just modify @content,@mode,@numbers, and @number
+  end
+  
+  def initialize string
+    generate string
+  end
+  
+  #### performance ####
+  def to_a
+    @numbers
+  end
+
+  def to_d
+    @numbers.collect{|n|n.to_s(10)}.join":"
+  end
+  
+  def to_h
+    @numbers.collect{|n|"%04x"%n}.join":"
+  end
+  
+  def to_s # s = short
+    IPAddr.new(@content).to_s
+  end
+  
+  def to_b
+    @numbers.collect{|n|"%016b"%n}.join":"
+  end
+
+  def + num
+    @number += num
+    generate(("%032x"%@number).unpack("a4a4a4a4a4a4a4a4").join(":"))
+  end
+  
+  def - num
+    @number -= num
+    generate(("%032x"%@number).unpack("a4a4a4a4a4a4a4a4").join(":"))
+  end
+  
+  #### mask ####
+  def mask_counter
+    if is_mask?
+      counter,msk = 0,to_b.gsub(':','')
+      while msk[-1]=='0'; counter += 1; msk = msk[0..-2]; end
+      return 128-counter
+    else
+      return nil
+    end
+  end
+  
+  def anti_mask_counter
+    if is_anti_mask?
+      counter,msk = 0,to_b.gsub(':','')
+      while msk[-1]=='1'; counter += 1; msk = msk[0..-2]; end
+      return counter
+    else
+      return nil
+    end
+  end
+  
+  def anti_mask
+    if (counter = mask_counter)
+      IPv6Mask.anti_number(counter)
+    else
+      warn "Not a net mask #{self}!";nil
+    end
+  end
+  
+  def mask
+    if (counter = anti_mask_counter)
+      IPv6Mask.number(counter)
+    else
+      warn "Not an anti-mask #{self}!";nil
+    end
+  end
+  
+  def is_mask?
+    !to_b.gsub(':','').include?('01')
+  end
+  
+  def is_anti_mask?
+    !to_b.gsub(':','').include?('10')
+  end
+  
+  #### network ####
+  def network_with mask
+    numbers = []
+    mask.numbers.each_with_index do|num,index|
+      numbers << (num & @numbers[index])
+    end
+    IPv6.new(numbers.collect{|n|"%0x"%n}.join(':'))
+  end
+  
+  def range_with mask
+    return self, self if mask.mask_counter.to_i == 128
+    net = network_with(mask)
+    (start_ip = net.clone) + 1
+    (end_ip = net.clone) + (2**(128-mask.mask_counter.to_i) - 1)
+    return start_ip,end_ip
+  end
+  
+  def is_network_with? mask
+    msk_counter,msk = 0,mask.to_b.gsub(':','')
+    while msk[-1]=='0'
+      msk_counter += 1
+      msk = msk[0..-2]
+    end
+    nt_counter,nt = 0,to_b.gsub(':','')
+    while nt[-1]=='0'
+      nt_counter += 1
+      nt = nt[0..-2]
+    end
+    return (nt_counter >= msk_counter) ? true : false
+  end
+  
+  def prefix_with another_ip
+    ip1 = self.to_b.gsub(':','')
+    ip2 = another_ip.to_b.gsub(':','')
+    count = 0
+    count += 1 while ip1[count] == ip2[count] && count < 128
+    return count
+  end
+end
+
+class IPv6Mask
+  def self.number num
+    hex = "%032x"%eval("0b"+"1"*num+"0"*(128-num))
+    str = hex.unpack("a4a4a4a4a4a4a4a4").join(":")
+    IPv6.new(str)
+  end
+
+  def self.string str
+    temp = IPv6.new(str)
+    unless temp.is_mask?
+      raise "Invalid net mask #{str}!"
+      return nil
+    else
+      return temp
+    end
+  end
+  
+  def self.anti_number num
+    hex = "%032x"%eval("0b"+"0"*num+"1"*(128-num))
+    str = hex.unpack("a4a4a4a4a4a4a4a4").join(":")
+    IPv6.new(str)
+  end
+  
+  def self.anti_string str
+    temp = IPv6.new(str)
+    unless temp.is_anti_mask?
+      raise "Invalid anti mask #{str}!"
+      return nil
+    else
+      return temp
+    end
+  end
+end
+
+module IP
+  def self.v6 string
+    ip,msk = string.split("/")
+    unless msk
+      return IPv6.new(ip)
+    else
+      mask = msk.include?(':') ? IPv6Mask.string(msk) : IPv6Mask.number(msk.to_i)
+      return IPv6.new(ip),mask
+    end
+  end
+end

data/utility/mac_address.rb

@@ -0,0 +1,77 @@
+#coding:utf-8
+
+class MacAddress
+  attr_reader :numbers,:number
+  
+  def full? sequence
+    (sequence.size!=3 && sequence.size!=6) ? false : true
+  end
+
+  def overflow? sequence,unit
+    max = 0
+    max = 65535 if sequence.size==3
+    max = 255 if sequence.size==6
+    return false if unit.to_i>max
+    return true
+  end
+
+  def valid? sequence
+    return "MAC地址长度错误(#{sequence.join('-')})!" unless full?(sequence)
+    sequence.each do|unit|
+      if unit.instance_of?(Numeric)
+        overflow = overflow?(sequence,unit)
+        return "MAC地址超出范围(#{sequence.join('-')})!" unless overflow
+      else
+        unit.to_s.each_char do|char|
+          return "MAC地址含有不合法字符(#{sequence.join('-')})!" unless /[A-F|a-f|0-9]/.match(char)
+        end
+      end
+    end
+    return "合法MAC地址"
+  end
+  
+  def calculate sequence
+    size = (sequence.size==3) ? (4):(2)
+    optr,result = "%0#{size}x",[]
+    sequence.each do|unit|
+      result << ( optr % eval("0x"+unit) ) if unit.is_a?(String)
+      result << ( optr % unit ) if unit.is_a?(Numeric)
+    end
+    result
+  end
+  
+  def == another
+    @number == another.number
+  end
+  
+  def initialize sequence
+    @numbers = []
+    valid = valid?(sequence)
+    if valid =="合法MAC地址"
+      @numbers = calculate(sequence)
+      @number = eval("0x"+@numbers.join)
+    else
+      warn valid
+    end
+  end
+  
+  def writing number=3,splitter='-'
+    number = 6 if number>=6
+    @numbers.each_slice(6/number.to_i).collect{|pile|pile.join}.join(splitter)
+  end
+
+end
+
+module MAC
+  def self.address sequence,def_splt='-'
+    seq = if sequence.is_a?(String)
+      splitter = '-' if sequence.include?('-')
+      splitter = '.' if sequence.include?('.')
+      splitter = def_splt unless def_splt==splitter
+      sequence.split(splitter)
+    else
+      sequence
+    end
+    MacAddress.new(seq)
+  end
+end

data/utility/netmerge.rb

@@ -0,0 +1,46 @@
+#coding:utf-8
+
+module Network
+  # 按网络归并地址段
+  # [ [ network(x.x.x.x), netmask(x.x.x.x) ], ... ] >=> [ [ network(x.x.x.x), netmask(x.x.x.x) ], ... ]
+  def self.merge raw_table
+    min,max = 32,0
+    nets = raw_table.map do|raw|
+      bin = IP.v4(raw[0]).to_b.gsub('.','')
+      num = IP.v4(raw[1]).mask_counter
+      min = num if min >= num
+      max = num if max <= num
+      net = bin[0..(num-1)]
+    end.sort_by{|net|net.size}.uniq # 按最短网络地址排序
+    
+    merge = []
+    nets.each do|net|
+      include = false
+      merge << net
+      merge.each do|sub|
+        include = true if /^#{sub}/.match(net) && net!=sub
+      end
+      merge.delete(net) if include
+    end # 网络地址匹配，仅保留最短网络地址
+    
+    diet_table = []
+    merge.each do|sub|
+      net = sub + "0"*(32-sub.size)
+      ip = net.unpack("a8a8a8a8").map{|i|eval("0b"+i)}.join(".")
+      network,netmask = IP.v4("#{ip}/#{sub.size}")
+      diet_table << [network.to_d,netmask.to_d]
+    end
+    return diet_table
+  end
+end
+
+
+__END__
+$LOAD_PATH << "."
+require 'ipv4_address'
+require 'neatjson'
+
+path = 'pubnet.json'
+raw = JSON.parse File.read path
+table = Network.merge raw
+File.write path.gsub('.json','_merge.json'),JSON.pretty_generate(table)

data/utility/route.rb

@@ -0,0 +1,79 @@
+#coding:utf-8
+
+module Route
+  module_function
+  # [destination, netmask, gateway, interface, owner, priority, metric]
+  
+  def match candiroutes, ipv4,backup_size = 2
+    backup_size < 0 and backup_size = 0
+    backup_routing_table = []
+    candiroutes.each do|pile|
+      net, mask = pile[0], pile[1]
+      l = ipv4.number >> (32-mask)
+      r = net.number >> (32-mask)  
+      l != r and next
+      backup_routing_table << pile
+    end
+    backup_stack = backup_routing_table.map{|r|r[1]}.uniq.sort.reverse[0..(backup_size-1)]
+    routing_table = backup_routing_table.select{|r|backup_stack.include? r[1]}.sort_by!{|r|r[1]}.reverse
+  end
+  
+  def merge candiroutes
+    merge_table = []
+    candiroutes = candiroutes.map do|c|
+      s = c[0].number
+      e = c[0].number + 2**(32-c[1]) - 1
+      c + [s, e, :yet]
+    end
+    candiroutes.each_with_index do|c, i|
+      candiroutes[(i+1)..(-1)].each do |cc|
+        cc[-1] == :bemerged and next
+        merged = c[-3] <= cc[-3] && cc[-2] <= c[-2]
+        bemerged = cc[-3] <= c[-3] && c[-2] <= cc[-2]
+        if merged
+          cc[-1] = :bemerged
+        elsif !merged && bemerged
+          c[-1] = :bemerged
+          break
+        end
+      end
+      merge_table << c[0..2] unless c[-1]==:bemerged
+    end
+    merge_table
+  end
+  
+end
+
+__END__
+$:<<"."
+require 'ipv4_address'
+
+=begin
+  ip = IP.v4('172.11.0.1')
+  n1,m1 = IP.v4('172.8.0.0/13')
+  n2,m2 = IP.v4('172.10.0.0/255.254.0.0')
+  n2_5,m2_5 = IP.v4('172.10.0.0/255.254.0.0')
+  n3,m3 = IP.v4('192.168.0.0/255.255.255.0')
+
+  candiroutes = [ 
+    [n1, m1.mask_counter, '1.1.1.1',:intf1, 'static', 1, 0],
+    [n2, m2.mask_counter, '2.2.2.2',:intf2, 'static', 1, 0],
+    [n3,m3.mask_counter, '3.3.3.3', :intf3, 'static', 0, 0],
+    [n2_5,m2_5.mask_counter, '4.4.4.4',:intf4, 'static', 1, 0]
+  ]
+
+  pp Route.match candiroutes, ip
+=end
+
+=begin
+  n1,m1 = IP.v4('172.8.0.0/13')
+  n2,m2 = IP.v4('172.10.0.0/255.254.0.0')
+  n3,m3 = IP.v4('192.168.0.0/255.255.255.0')
+
+  candiroutes = [
+    [n1, m1.mask_counter, '1.1.1.1', :intf, 'static', 1, 0],
+    [n2, m2.mask_counter, '1.1.1.1', :intf, 'static', 1, 0],
+    [n3, m3.mask_counter, '1.1.1.1', :intf, 'static', 1, 0]
+  ]
+  pp Route.merge candiroutes
+=end

data/utility/whitelist.rb

@@ -0,0 +1,21 @@
+#coding:utf-8
+
+class WhiteList
+  attr_reader :allowed
+
+  def initialize path
+    pubnet = JSON.parse File.read path
+    @allowed = pubnet.inject([]) do|allowed,network|
+      ip,mask = IP.v4(network.join('/'))
+      start_ip,end_ip = ip.range_with(mask)
+      allowed << [start_ip, end_ip]
+      allowed
+    end
+    @allowed
+  end
+
+  def allow? ip
+    @allowed.inject(false){|flag, range| flag || (range[0].number..range[1].number).include?(ip.number)}
+  end
+end
+