gnms 2.1.0.rc1

data/lib/interface.rb

@@ -0,0 +1,16 @@
+class Interface
+
+attr_accessor :name, :link_status, :speed, :type
+
+	def initialize (n, lstatus=nil, sp=nil, tp=nil)
+		@name = n
+		@link_status = lstatus
+		@speed = sp
+		@type = tp
+	end
+
+	def to_s()
+		print "Interface: ", @name, " ", @link_status, " ", @speed, " ", @type, "\n"
+	end
+
+end #class

data/lib/ipcalc.rb

@@ -0,0 +1,266 @@
+module IPCalc
+
+def IPCalc.bits_to_netmask(bits)
+	bits=bits.to_i()
+	if bits <=0
+		return "0.0.0.0"
+	end
+	if bits >= 32
+		return "255.255.255.255"
+	end
+
+	cpt=0
+	cpt_byte=8
+	result=""
+	result_val=0
+	while bits >= 0 ||cpt <= 32
+		val=1
+		val=0 unless bits > 0
+		if cpt%8==0
+			if cpt != 0
+			result+="#{result_val}"
+			result+="." unless cpt == 32
+			cpt_byte=8
+			result_val=0
+			end
+		end
+		result_val+=2**(cpt_byte-1)*val
+		cpt_byte-=1
+		cpt+=1
+		bits-=1
+	end
+	return result
+end
+
+def IPCalc.netmask_to_bits(netmask)
+	#verify if netmask is an 4 dot format
+	if netmask.nil? or netmask.empty? or !isValidIPv4(netmask)
+		return nil
+	end
+	netmask_t=netmask.split(/\./)
+	result_val=0
+
+	for val in netmask_t
+   	cpt_byte=8
+		val_tmp=val.to_i()
+		while val_tmp > 0
+			val_tmp-=2**(cpt_byte-1)
+			cpt_byte-=1
+			result_val+=1
+		end
+	end
+	return result_val
+end
+
+
+#
+#	take an integer
+#
+def IPCalc.get_wildcard(mask)
+	mask_local=mask
+	if mask.to_s().match('^\d+$')
+		mask_local=bits_to_netmask(mask)
+	end
+	#verify if mask_local is an 4 dot format
+	if !isValidIPv4(mask_local)
+		return nil
+	end
+	netmask_t=mask_local.split(/\./)
+	result=""
+	for val in netmask_t
+		val_tmp=val.to_i()
+		result+="#{255-val_tmp}."
+	end
+	return result.chop
+end
+
+def IPCalc.get_network_and_mask(addr)
+	#verify if addr is an 4 dot format string
+	if !isValidIPv4(addr)
+		return nil
+	end
+	result_t=[]
+	mask=class_type_default_mask(addr)
+	wildcard=get_wildcard(mask)
+	wildcard_t=wildcard.split(/\./)
+	addr_t=addr.split(/\./)
+	cpt=0
+	for wildc in wildcard_t
+		if wildc != "0"
+			addr_t[cpt]="0"
+		end
+		cpt+=1
+	end
+	result=addr_t.join(".")
+	if result == addr
+		return nil
+	else
+		result_t.push result
+		result_t.push mask
+		return result_t
+	end
+end
+
+def IPCalc.get_network_addr(addr, mask)
+	#verify if addr is an 4 dot format string
+	if !isValidIPv4(addr)
+		return nil
+	end
+	wildcard=get_wildcard(mask)
+	wildcard_t=wildcard.split(/\./)
+	addr_t=addr.split(/\./)
+	cpt=0
+	for wildc in wildcard_t
+		if wildc != "0"
+			addr_t[cpt]="0"
+		end
+		cpt+=1
+	end
+	return addr_t.join(".")
+end
+
+def IPCalc.get_broadcast(network, mask)
+	#verify if network is an 4 dot format string
+	if !isValidIPv4(network)
+		return nil
+	end
+	wildcard=get_wildcard(mask)
+	wildcard_t=wildcard.split(/\./)
+	addr_t=network.split(/\./)
+	cpt=0
+	for wildc in wildcard_t
+		if wildc=="0"
+			wildcard_t[cpt]=addr_t[cpt] unless addr_t[cpt] == "0"
+		end
+		cpt+=1
+	end
+	return wildcard_t.join(".")
+
+end
+
+def IPCalc.nb_host(netmask)
+	mask=netmask
+	if !netmask.to_s().match('^\d+$')
+		mask=netmask_to_bits(netmask)
+	end
+	if mask==nil
+		return nil
+	end
+	mask=mask.to_i()
+	result=2**(32-mask)-2
+	result=1 if result<=0
+	return result
+end
+
+def IPCalc.to_bitwise(four_dot_addr)
+	#verify if four_dot_addr is an 4 dot format string
+	if !isValidIPv4(four_dot_addr)
+		return nil
+	end
+	four_dot_addr_t=four_dot_addr.split(/\./)
+	result=""
+	for four_dot_split in four_dot_addr_t
+		byte_val=8
+		while four_dot_split.to_i>0
+			if four_dot_split.to_i >= 2**(byte_val-1)
+				result+="1"
+			four_dot_split=four_dot_split.to_i()-2**(byte_val-1)
+			else
+				result+="0"
+			end
+			byte_val-=1
+		end
+		result+="0"*byte_val
+		result+="."
+	end
+	return result.chop
+end
+
+def IPCalc.class_type_name(network)
+	class_name="class"
+	mask=network
+	if network.to_s().match('^\d+$')
+		mask=bits_to_netmask(network)
+	end
+	if mask==nil
+		return nil
+	end
+	bitmask=to_bitwise(mask)
+	if bitmask.to_s().match('^0')
+		return class_name+" "+"A"
+	elsif bitmask.to_s().match('^10')
+		return class_name+" "+"B"
+	elsif bitmask.to_s().match('^110')
+		return class_name+" "+"C"
+	elsif bitmask.to_s().match('^1110')
+		return class_name+" "+"D"
+	elsif bitmask.to_s().match('^1111')
+		return class_name+" "+"E"
+	end
+end
+
+def IPCalc.class_type_default_mask(addr)
+	#verify if addr is an 4 dot format string
+	if !isValidIPv4(addr)
+		return nil
+	end
+	class_name="class"
+	mask=addr
+	if addr.to_s().match('^\d+$')
+		mask=bits_to_netmask(netmask)
+	end
+
+	bitmask=to_bitwise(mask)
+	if bitmask.to_s().match('^0')
+		return 8
+	elsif bitmask.to_s().match('^10')
+		return 16
+	elsif bitmask.to_s().match('^110')
+		return 24
+	elsif bitmask.to_s().match('^1110')
+		return 4
+	elsif bitmask.to_s().match('^1111')
+		return 4
+	end
+end
+
+#
+# launch ipcalculator ip can be a 4 dot addr or addr/bitmask
+#
+def IPCalc.ipcalc_detail(addr_str)
+	addr=""
+	mask=""
+	if isValidIPv4(addr_str)
+		#we need default mask
+		addr=addr_str
+		mask=class_type_default_mask(addr_str)
+	elsif addr_str.match('^[\d.]+\/\d+$')
+		addr,mask=addr_str.split(/\//)
+	end
+	result=
+	"Address: "+addr+"\n"+
+	"NetMask: "+mask+"\n"+
+	"Wildcard: "+get_wildcard(mask)+"\n"+
+	"Network: "+get_network_addr(addr,mask)+"\n"+
+	"Broadcast: "+get_broadcast(addr,mask)+"\n"+
+	"Hosts: "+nb_host(mask).to_s()+"\n"+
+	"Type: "+class_type_name(addr)+"\n\n";
+
+	#HostMin:
+	#HostMax:
+  return result
+end
+
+#puts bits_to_netmask(ARGV[0].to_i)
+#puts netmask_to_bits("0.0.0.0")
+#puts get_wildcard("255.255.252.0")
+#puts get_wildcard(22)
+#puts get_broadcast("12.168.1.0",22)
+#puts get_network_addr("12.168.1.2",22)
+#puts nb_host(22)
+#puts to_bitwise("192.168.1.1")
+#puts class_type_name("18.0.0.0")
+#puts get_network_and_mask("10.10.1.1")
+
+#to do : hostmin hostmax priv/pub
+end

data/lib/link.rb

@@ -0,0 +1,45 @@
+require "#{GNMSLIB}"+'/gui/link_view'
+
+class Link
+	attr_accessor :node1, :node2
+
+   def initialize(n1, n2)
+	#true for up, false for down
+	@state=true
+	@name=nil
+	@speed=nil
+	@node1=n1
+	@node2=n2
+	$links.push(self)
+	@node1.add_link(self)
+	@node2.add_link(self)
+	@view=LinkView.new(n1.map, self, [@node1.status, @node2.status].max)
+   end
+
+	def point?(node)
+		if (node==@node1) || (node==@node2)
+			return true
+		end
+		return false	
+	end
+
+	def show()
+		@view.show()
+	end
+
+	def hide()
+		@view.hide()
+	end
+
+	def display()
+		@view.display()
+	end
+
+	def remove_link()
+		@view.remove_link()
+	end
+	
+	def update_status()
+	  @view.update_status([@node1.status, @node2.status].max)
+	end
+end #class

data/lib/main.rb

@@ -0,0 +1,1091 @@
+require 'gdk_pixbuf2'
+
+begin
+	require 'rubygems'
+	$defined_lib_gruff=true
+rescue LoadError
+	$log.error("rubygems library is missing thus gruff library for report will not be loaded")
+	$defined_lib_gruff=false
+end
+
+begin
+  require 'goocanvas'
+rescue LoadError
+  $log.fatal("You must install goocanvas module for ruby")
+  exit()
+end
+
+begin
+  require 'facter'
+  require 'facter/util/ip'
+rescue LoadError
+  $log.fatal("You must install facter lib for ruby to be able to extract system info")
+  exit()
+end
+
+require 'securerandom'
+require 'syslog'
+require 'tempfile'
+require 'optparse'
+require 'base64'
+
+begin
+  require 'snmp'
+rescue LoadError
+  $log.fatal("You must install snmp module for ruby from http://snmplib.rubyforge.org/")
+  exit()
+end
+
+begin
+  require 'sqlite3'
+  if !SQLite3::VERSION.match("^1\.3")
+    raise LoadError
+  end
+rescue LoadError
+  $log.fatal("You must install SQLite v3 module for ruby from http://rubyforge.org/projects/sqlite-ruby")
+  exit()
+end
+
+begin
+  require 'gst'
+  Gst.init([])
+  $defined_lib_gst=true
+rescue LoadError
+  $log.error("You will not be able to play sound files, you need ruby lib gstreamer (libgst)")
+  $defined_lib_gst=false
+end
+
+require "#{GNMSLIB}"+'/monitor/client/snmp/oid_ref'
+require "#{GNMSLIB}"+'/monitor/client/wmi/wmi_ref'
+require "#{GNMSLIB}"+'/monitor/client/jmx/jmx_ref'
+require "#{GNMSLIB}"+'/monitor/server/syslog/syslog_ref'
+require "#{GNMSLIB}"+'/monitor/server/snmp/snmptrap_ref'
+
+require "#{GNMSLIB}"+'/node'
+require "#{GNMSLIB}"+'/node_host'
+require "#{GNMSLIB}"+'/node_network'
+require "#{GNMSLIB}"+'/link'
+require "#{GNMSLIB}"+'/gui/event_window'
+require "#{GNMSLIB}"+'/gui/canvas_map'
+require "#{GNMSLIB}"+'/monitor/server/syslog/syslog_capture'
+require "#{GNMSLIB}"+'/monitor/server/snmp/snmptrap_capture'
+require "#{GNMSLIB}"+'/format'
+require "#{GNMSLIB}"+'/contact'
+require "#{GNMSLIB}"+'/external/crypt/blowfish'
+require "#{GNMSLIB}"+'/external/fog'
+
+#SMS lib from http://raa.ruby-lang.org/project/ruby-sms/
+#need serialport lib too http://raa.ruby-lang.org/project/ruby-serialport/
+
+begin
+  require "#{GNMSLIB}"+'/external/sms.rb'
+rescue LoadError
+  $log.error("SMS notification disabled, library ruby-serialport is missing")
+  $defined_lib_sms=false
+end
+
+################################################################################
+# Main Event Window
+################################################################################
+
+
+#
+# return a version 4 UUID
+# it's std lib in ruby 1.9
+#
+def create_uuid()
+  if (defined?(SecureRandom.uuid))
+    SecureRandom.uuid
+  else
+    ary = SecureRandom.random_bytes(16).unpack("NnnnnN")
+    ary[2] = (ary[2] & 0x0fff) | 0x4000
+    ary[3] = (ary[3] & 0x3fff) | 0x8000
+    "%08x-%04x-%04x-%04x-%04x%08x" % ary
+  end
+end
+
+def blowfish_encode(str)
+  begin
+    blowfish = Crypt::Blowfish.new(GNMSPPH)
+    return blowfish.encrypt_string(str)
+  rescue
+    $log.debug("error when blowfish encoding")
+  end
+  return ""
+end
+
+def blowfish_decode(str)
+  begin
+    blowfish = Crypt::Blowfish.new(GNMSPPH)
+    return blowfish.decrypt_string(str)
+  rescue
+    $log.debug("error when blowfish decoding")
+  end
+  return ""
+end
+
+#
+#	return current snmp version from version str
+#
+def get_snmp_version(str)
+  if str == SNMPv2
+    return :SNMPv2c
+  else
+    return :SNMPv1
+  end
+end
+
+def get_color_from_status(status)
+  case status
+  when "CRITICAL"
+    return $red
+  when "MAJOR"
+    return $orange
+  when "WARNING"
+    return $yellow
+  when "MINOR"
+    return $blue
+  when "NORMAL"
+    return $green
+  when "UNMANAGED"
+    return $grey
+  when "UNKNOWN"
+    return $purple
+  end
+end
+
+#
+#	convert status to level
+#  can return a level or '' if not convert or "UNKNOWN", "UNMANAGED" if "UNMANAGED"
+def get_level_from_status(status)
+  case status
+  when "UNMANAGED"
+    return "UNMANAGED"
+  when "CRITICAL"
+    return "PANIC"
+  when "MAJOR"
+    return "ALERT"
+  when "WARNING"
+    return "ERR"
+  when "MINOR"
+    return "WARN"
+  when "NORMAL"
+    return "INFO"
+  else
+    return ""
+  end
+end
+
+def get_status_from_level(level)
+  case level
+  when "UNMANAGED"
+    return "UNMANAGED"
+  when "PANIC"
+    return "CRITICAL"
+  when "ALERT"
+    return "MAJOR"
+  when "ERR"
+    return "WARNING"
+  when "WARN"
+    return "MINOR"
+  when "INFO"
+    return "NORMAL"
+  else
+    return "UNKNOWN"
+  end
+end
+
+
+def exist_monitoring_thread(str)
+  return $thread_list[str] != nil
+end
+
+def add_monitoring_thread(str, thr)
+  $log.debug("Starting thread #{str}")
+  if thr
+    $thread_list[str]=thr
+    if thr.class == Thread
+      $threads.add(thr)
+    else
+      $log.error("Thread #{str} could not be loaded")      
+    end
+  else
+    $log.debug("Thread #{str} not started")  
+  end
+end
+
+#
+#	remove thread from thread group
+#
+def del_monitoring_thread(str)
+  if $thread_list[str] != nil
+    $log.debug("Removing thread #{str}")
+    ThreadGroup.new.add($thread_list[str])
+    $thread_list.delete(str)
+  end
+end
+
+#
+#	popup to confirm application exit
+#
+def confirm_exit_window()
+  $in_confirm_exit_window=true
+  if $config.confirm_quit
+    dialog = Gtk::MessageDialog.new($win, Gtk::Dialog::DESTROY_WITH_PARENT,
+    Gtk::MessageDialog::QUESTION,
+    Gtk::MessageDialog::BUTTONS_YES_NO,
+    "Do you really want to quit ?")
+    dialog.run do |r|
+      dialog.destroy
+      if r == Gtk::Dialog::RESPONSE_NO then
+        $in_confirm_exit_window=false
+        return true
+      else
+        return false
+      end
+    end
+  else
+    return false
+  end
+end
+
+#
+#	fill ip str with prepending zero chars
+#
+def fill_ip_str(ip)
+  if ip.nil?
+    return nil
+  end
+  table=ip.split(/\./)
+  if table.length != 4
+    return nil
+  end
+  ip_tmp=""
+  for i in 0..table.size-1
+    ip_tmp+="0"*(3-table[i].length)+table[i]
+    ip_tmp+="." unless i==table.size-1
+  end
+  return ip_tmp
+end
+
+def get_map_width()
+  if $win.window != nil
+    return $win.window.geometry[2]
+  else
+    return $root_width
+  end
+end
+
+def get_map_height()
+  if $win.window != nil
+    return $win.window.geometry[3]
+  else
+    return $root_height
+  end
+end
+
+def get_default_map_width()
+  if $config.default_width == nil || $config.default_width == ""
+    return Gdk::screen_width/2
+  else
+    return $config.default_width.to_i
+  end
+end
+
+def get_default_map_height()
+  if $config.default_height == nil || $config.default_height == ""
+    return Gdk::screen_height/2
+  else
+    return $config.default_height.to_i
+  end
+end
+
+def del_selected_node()
+  mapp=get_map()
+  if $map != nil
+    nodes=[]
+    $network[mapp].get_node().each_value {|node|
+      if node.node_view.selected?()
+        nodes.push(node)
+      end
+    }
+    verify_delnodewin(nodes) unless nodes.size() == 0
+  end
+end
+
+#
+#	try to display node of map arg as a grid
+#	need: an ip addr map
+#
+def layout_grid(map)
+  if map != nil
+
+    root_width=$win.window.geometry[2]
+    root_height=$win.window.geometry[3]
+    x=0
+    y=0
+
+    $network[map].get_node().each_value {|node|
+      node_v = node.node_view
+      if node_v
+        node_size=node_v.get_node_size()
+        node_v.move(x-node.x, y-node.y)
+        x+=node_size+root_width/node_size
+        if x >= root_width
+          x=0
+          y+=node_size+node_size/2+root_height/node_size
+        end
+        if node.nb_links > 0
+          node.get_links().each {|lnk|
+            lnk.remove_link
+            lnk.display()
+          }
+        end
+      end
+    }
+  end
+end
+
+#
+#	return the number of host
+#
+def n_host()
+  return $host.size
+end
+
+#
+#	return the number of network
+#
+def n_network()
+  return $network.size
+end
+
+#
+#	return true if host ip addr is known
+#	need: ip
+#
+def exist_host(ip)
+  return $host[ip] != nil
+end
+
+#
+# del host from a network
+#
+def del_host(ip)
+  #we first update network list
+  $network[$host[ip].map].del_host(ip)
+  $network[$host[ip].map].update_status()
+  $host.delete ip
+  $event_win.update_statusbar()
+end
+
+#
+# add host to a network
+#
+def add_host(ip, mask, map=ROOTMAPADDR)
+  if $host[ip] == nil
+    $host[ip]=Host.new(ip, mask, nil, nil, map)
+    #we update network host list
+    if $network[map]
+      $network[map].add_host($host[ip])
+      $host[ip].node_view.show() if map==get_map()
+      $network[map].update_status()
+      $event_win.update_statusbar()
+      return true
+    end
+  end
+  return false
+end
+
+#
+#	return true if network ip addr is known
+#	need: ip
+#
+def exist_network(ip)
+  return $network[ip] != nil
+end
+
+#
+#	delete a network
+#	need: ip
+#
+def del_network(ip)
+  if ip != ROOTMAPADDR
+    $network[ip].get_node().each_key {|id|
+      $host[id].delete() unless $host[id] == nil
+    }
+    $network[ip].network.each_key {|network_ip|
+      $network[network_ip].delete()
+    }
+    #del network from gui elements
+    $network[$network[ip].map].del_net(ip) unless $network[$network[ip].map] == nil
+    #del network from network list
+    $network.delete ip
+  end
+end
+
+#
+#	add a network
+#	need: ip, mask, map
+#
+def add_network(ip, mask, map)
+  if map != nil && $network[ip] == nil && $host[ip] == nil
+    $network[ip]=Network.new(ip, mask, nil, nil, map)
+    $network[ip].node_view.show() if map==get_map()
+    #add network in network map
+    $network[map].add_network($network[ip])
+    return true
+  end
+  $log.error("IP addr #{ip} already in use") if map != nil
+  return false
+end
+
+#
+#	return table of network ip
+#
+def get_network()
+  hnet=[]
+  $network.each_value {|node|
+    #if node.name?
+    #	hnet.push node.name
+    #else
+    hnet.push node.ip
+    #end
+  }
+  return hnet
+end
+
+#
+#	set current network map window title
+# 	input: ip map addr
+#
+def set_map_window_title(mp)
+  txt=mp
+  if  txt && $network[txt] && $network[txt].name?()
+    txt=$network[txt].name
+  end
+  $win.set_title("Map #{txt}")
+end
+
+#
+#	return current network map
+#
+def get_map()
+  if $map == nil
+    return ROOTMAPADDR
+  else
+    return $map
+  end
+end
+
+#
+# set current map by is IP addr
+#
+def set_map(mp=nil)
+
+  $canvas.get_selected_node().each {|n|
+    n.node_view.unselect()
+    } unless $canvas == nil
+    #first set map
+    if $map == nil && mp ==nil && $network[ROOTMAPADDR]
+      #puts "1"
+      $network[ROOTMAPADDR].node_view.show()
+      $network[ROOTMAPADDR].map_view.visibility = Goo::CanvasItem::INVISIBLE
+    else
+      if $map == nil && $network[ROOTMAPADDR]
+        #puts "2"
+        #only the network root can have a nil map
+        $network[ROOTMAPADDR].get_node().each_value {|node|
+          node.node_view.hide_text() unless !node.node_view
+        }
+        $network[ROOTMAPADDR].node_view.hide()
+      else
+        if $network[ROOTMAPADDR]
+           $network[$map].get_node().each_value {|node|
+             node.node_view.hide_text() unless !node.node_view
+           }
+           $network[$map].map_view.visibility = Goo::CanvasItem::INVISIBLE
+	end
+      end
+      if mp == nil && $network[ROOTMAPADDR]
+        #puts "4"
+        #only the network root can have a nil map
+        $network[ROOTMAPADDR].node_view.resize()
+        $network[ROOTMAPADDR].reload()
+        if $network[ROOTMAPADDR].set_label_visibility()
+          $network[ROOTMAPADDR].change_label($config.network_label_view)
+          $network[ROOTMAPADDR].node_view.show_text()
+        else
+          $network[ROOTMAPADDR].node_view.hide_text()
+        end
+        $network[ROOTMAPADDR].node_view.show()
+        if $config.bg_type == "color"
+          $canvas.unset_background_image()
+          set_background_color($config.rgb)
+        else
+          $canvas.set_background_image("#{PIXMAP_PATH}"+"/"+$config.image_path)
+        end
+        $win.hide_menu_entry()
+      else
+        #for each node of the new map, we refresh size icon, icon type and label type
+        tmp_node=$network[mp]
+        if tmp_node
+          tmp_node.get_node().each_value {|n|
+            n.node_view.resize() unless !n.node_view
+            #n.reload()
+            if n.set_label_visibility()
+              if n.class == Network
+                n.change_label($config.network_label_view)
+              elsif n.class == Host
+                n.change_label($config.host_label_view)
+                n.refresh_dns_name()
+              end
+              n.node_view.show_text() unless !n.node_view
+            else
+              n.node_view.hide_text() unless !n.node_view
+            end
+            #show the node icon view
+            n.node_view.show() unless !n.node_view
+          }
+
+          $network[mp].map_view.visibility = Goo::CanvasItem::VISIBLE
+
+          #test $map and mp bg_type ?
+          #puts $network[mp].map_bg_type
+          if ($network[mp].map_bg_type != nil)
+            if $network[mp].map_bg_type == "color"
+              if ($network[mp].map_bg_data != $config.rgb) || ($config.bg_type == "image")
+                $canvas.unset_background_image()
+                set_background_color($network[mp].map_bg_data)
+              end
+            else
+              if ($config.bg_type!=$network[mp].map_bg_type) || ( ($config.bg_type==$network[mp].map_bg_type) && ($network[mp].map_bg_data != $config.image_path))
+                $canvas.set_background_image("#{PIXMAP_PATH}"+"/"+$network[mp].map_bg_data)
+              end
+            end
+          else
+            if $config.bg_type == "color"
+              $canvas.unset_background_image()
+              set_background_color($config.rgb)
+            else
+              if (!$canvas.background_image_isset?()) || ($network[mp].map_bg_data != $config.image_path)
+                $canvas.set_background_image("#{PIXMAP_PATH}"+"/"+$config.image_path)
+              end
+            end
+          end
+          $win.show_menu_entry()
+        end
+      end
+      $map=mp
+      set_map_window_title(mp)
+    end
+  end
+
+  #
+  #	set map window background rgb color
+  #
+  def window_set_rgb(r, g, b)
+    style=Gtk::Style.new
+    style.set_bg(Gtk::STATE_NORMAL, r, g, b)
+    style.set_bg(Gtk::STATE_ACTIVE, r, g, b)
+    style.set_bg(Gtk::STATE_PRELIGHT, r, g, b)
+    $win.set_style style
+  end
+
+  #
+  #	set map window background color
+  #
+  def set_background_color(rgb)
+    r,g,b=rgb.to_a()
+    r=r.to_f
+    g=g.to_f
+    b=b.to_f
+    window_set_rgb(r, g, b) unless $win == nil
+    $canvas.set_rgb(r, g, b) unless $canvas == nil
+  end
+
+  #
+  #	select all node of the map
+  #
+  def select_all_node()
+    $network[get_map()].get_node().each_value {|n|
+      n.node_view.select()
+    }
+  end
+
+  #
+  #	invert node selection of the map
+  #
+  def invert_selected_node()
+    $network[get_map()].get_node().each_value {|n|
+      if n.node_view.selected?()
+        n.node_view.unselect()
+      else
+        n.node_view.select()
+      end
+    }
+  end
+
+  def check_contact_value(hash)
+    hash_bck=Hash.new
+    hash.each_key {|id|
+      hash_bck[id]=hash[id].dup unless !hash[id]
+    }
+    hash.each_pair{|key, value|
+      if key != nil
+        value.each {|contact|
+          if !Contact::contact_exist?(contact.firstname, contact.lastname)
+            #contact does not exist anymore
+            hash_bck[key].delete(contact)
+          else
+            #contact exist so we set it "in-use"
+            Contact::add_use(contact.firstname, contact.lastname)
+          end
+          } unless !value
+        end
+      }
+      return hash_bck
+    end
+
+
+    #
+    #  switch main window visibility
+    #
+    def switch_main_visibility()
+      if $icon
+        $icon.set_blinking(false)
+        if $win.visible?
+          $win.hide
+        else
+          $win.show
+        end
+      end
+    end
+
+    #
+    # create main network map window
+    #
+    def map_window()
+      nbuttons = n_host()
+
+      begin
+        #it depends on gnome version
+        $icon = Gtk::StatusIcon.new
+        $icon.set_pixbuf(Gdk::Pixbuf.new("#{PIXMAP_PATH}/logo_icon.png"))
+        $icon.signal_connect('activate') { switch_main_visibility }
+      rescue
+        $icon=nil
+      end
+
+      $win = App.new("Map")
+      $win.set_default_size(get_default_map_width(), get_default_map_height())
+      $win.resize(get_default_map_width(), get_default_map_height())
+
+      #here we set the background color
+      window_set_rgb($config.rgb[0].to_f, $config.rgb[1].to_f, $config.rgb[2].to_f)
+      $win.signal_connect("delete_event") {
+        $root_width=$win.window.geometry[2]
+        $root_height=$win.window.geometry[3]
+
+        #check if the current windowmanager display the trayicon
+        if $icon && $icon.embedded?
+          #if it's the case we just hide the main window
+          $win.hide
+        else
+          confirm_exit_window()
+        end
+      }
+
+      $win.signal_connect("destroy") {
+      }
+      
+      $win.signal_connect("configure_event") {|w,e|
+        #size or position changed
+        if $win != nil
+          if (($root_width != e.width) or ($root_height != e.height))
+            if (!$win.get_size_changed_from_menu())
+              $win.set_display_view_menu()
+            end
+            $win.set_size_changed_from_menu(false)
+          end
+        end
+      }
+
+      #read command line options
+      file_to_load=nil
+      debuglevel=nil
+      $testunit=false
+      testunitfile=nil
+
+      opts = OptionParser.new
+      opts.on("-f=ARG", "--file filename",String,"Load xml node filename") {|val| file_to_load=val }
+      opts.on("-d=ARG", "--debug level",Integer,"Set debug level to default output") {|val| debuglevel=val }
+      opts.on("-t=ARG", "--test scenario",String,"Load and execute scenario from test/ dir") {|val| testunitfile=val
+        $testunit=true
+      }
+      opts.on("-h", "--help","Show this help") {|val| puts opts.to_s; exit}
+      opts.on("-v", "--version","Display GNMS version") {|val| puts "GNMS version is #{GNMSVERSION}"; exit}
+
+      begin
+        opts.parse(ARGV)
+      rescue OptionParser::MissingArgument => msg
+      rescue OptionParser::InvalidOption => msg
+      rescue OptionParser::InvalidArgument => msg
+        $log.error("#{msg}")
+        exit
+      end
+
+      if (debuglevel != nil) && (debuglevel >= 0) && (debuglevel < 5)
+        $log.level=debuglevel
+      end
+
+      if testunitfile == nil
+        if file_to_load != nil
+          if FileTest.exist?(file_to_load)
+            $log.info("Loading nodes from file #{file_to_load}")
+            read_xml(file_to_load)
+          else
+            $log.error("#{file_to_load} is not an host db file")
+            exit
+          end
+        else
+          if FileTest.exist?(SQLITE_DB)
+            $log.info("Loading nodes from database")
+            db_read()
+            #we have to verify if account from conf file and from db matched
+            $config.mail_by_level=check_contact_value($config.mail_by_level)
+            $config.sms_num_by_level=check_contact_value($config.sms_num_by_level)
+            $config.im_dest_by_level=check_contact_value($config.im_dest_by_level)
+          else
+            create_db()
+            #as we don't have account in db we will assure no account come from conf file
+            $config.init_hash_conf_by_level($config.mail_by_level)
+            $config.init_hash_conf_by_level($config.sms_num_by_level)
+            $config.init_hash_conf_by_level($config.im_dest_by_level)
+
+            if n_host() == 0
+              $log.info("Creating default node based on local interfaces")
+              create_root_network()
+              for interface in local_interface()
+                #syntax array of [ipv4 mask ipv6 mac_addr interface_name]
+		(ipv4, mask, ipv6, mac_addr, interface_name) = interface
+		if !exist_host(ipv4)
+                  if add_host(ipv4, IPCalc.netmask_to_bits(mask))
+		     if mac_addr
+		        $host[ipv4].mac = mac_addr
+		     end
+		     if interface_name
+		        $host[ipv4].add_interface(interface_name)
+		     end
+		     #then try to add naming info and os
+		     tmp = Facter::hostname
+		     if tmp
+		       #special case
+		       if ipv4 == "127.0.0.1"
+		          tmp="localhost"
+		       end
+		       $host[ipv4].name = tmp
+		     end
+		     tmp = nil
+		     tmp = Facter::domain
+		     if tmp
+		       $host[ipv4].dns_domain = tmp		       
+		     end
+		     tmp = nil
+		     tmp = Facter::fqdn
+		     if tmp
+		       $host[ipv4].dns_name = tmp		       
+		     end
+		     tmp = nil
+		     tmp = Facter::kernel
+		     if tmp
+		       $host[ipv4].os = tmp.downcase
+		     end
+                     tmp = nil		     
+		  end
+                end
+              end
+            end
+          end
+        end
+        #set current map
+        map_tmp=nil
+        if $config.default_map != ""
+          if exist_network($config.default_map)
+            map_tmp=$config.default_map
+          end
+        end
+        #here we also set the pixmap background
+        set_map(map_tmp)
+      else
+        #execute the test unit script
+        $log.info("Running test scenario #{TEST_DIR}/#{testunitfile}")
+        File.delete(SQLITE_DB_TEST) unless !FileTest.exist?(SQLITE_DB_TEST)
+        File.delete(GLOBAL_CONF_TEST_FILE) unless !FileTest.exist?(GLOBAL_CONF_TEST_FILE)
+        create_db(SQLITE_DB_TEST)
+        #as we don't have account in db we will assure no account come from conf file
+        $config.init_hash_conf_by_level($config.mail_by_level)
+        $config.init_hash_conf_by_level($config.sms_num_by_level)
+        $config.init_hash_conf_by_level($config.im_dest_by_level)
+        create_root_network()
+
+        begin
+          require "#{TEST_DIR}/#{testunitfile}"
+          cmd="#{testunitfile[0,1].capitalize()}#{testunitfile[1,testunitfile.size - 1]}"
+          (eval cmd).new
+        rescue Exception => msg
+          print #{msg.backtrace.join("\n")},"\n"
+          $log.fatal("Test scenario #{TEST_DIR}/#{testunitfile}.rb does not exist")
+          exit()
+        end
+      end
+
+      #hide splash_screen
+      #splash_screen.hide
+      #splash_screen.destroy
+
+      $win.set_icon_name("MAP")
+      $win.set_icon("#{PIXMAP_PATH}/logo_icon.png")
+      $win.show
+      $root_width, $root_height=$win.size
+
+      if ! FileTest.exist?(GLOBAL_CONF_FILE)
+        $config.show()
+      end
+
+    end
+
+    def check_scanner_version()
+      if $config.nmap_path
+        $config.nmap_vers=nmap_version()
+        if $config.nmap_vers == nil
+          $log.warn("You should install NMAP version from http://www.insecure.org/nmap/ to access full features")
+        else
+          if  $config.nmap_vers.to_i() < 4
+            $log.info("You should update NMAP to latest version from http://www.insecure.org/nmap/")
+          end
+        end
+      end
+    end
+
+    #
+    #	main
+    #
+    def launch_gnms_main()
+
+      #  begin
+
+      Thread.abort_on_exception = true
+
+      $config=ConfigGlobal.new()
+      #read config
+      $config.read_config_yaml()
+      
+      #set saved log level
+      $log.level = txtlvl_to_loggerlvl($config.log_level)
+
+      #verify nmap version
+      check_scanner_version()
+
+      #create host hash
+      $host=Hash.new
+
+      #create network hash
+      $network=Hash.new
+
+      #create link hash for global operation
+      $links=[]
+
+      #oid ref for snmp monitoring
+      $oid_refs=Hash.new
+      #wmi ref for wmi monitoring
+      $wmi_refs=Hash.new
+      #syslog ref for syslog monitoring
+      $syslog_refs=Hash.new
+      #snmptrap ref for snmptrap monitoring
+      $snmptrap_refs=Hash.new
+      #http ref for http monitoring
+      $http_refs=Hash.new
+      #jmx ref for jmx monitoring
+      $jmx_refs=Hash.new
+
+      #create contacts
+      $contact=Hash.new
+
+      Syslog.open(PROJECTNAME, Syslog::LOG_PID | Syslog::LOG_NDELAY)
+
+      #load some hidden window in background
+      $treenode_win=TreeNodeWindow.new
+      $event_win=EventWindow.new
+
+      #by default first map is root map
+      $map=nil
+      map_window()
+
+      #we have loaded all node
+      $event_win.update_statusbar()
+      $treenode_win.reload()
+      thread_starting()
+
+      interfaces_table = local_interface()
+      if interfaces_table.size > 0
+        ip_of_first_interface = interfaces_table[0][0]
+        $event_win.add_event(EventWindow::CORE_EVENT_TYPE,"INFO",$host[ip_of_first_interface], "GNMS launch")
+      else
+        $event_win.add_event(EventWindow::CORE_EVENT_TYPE,"INFO",$host["127.0.0.1"], "GNMS launch")
+      end
+
+      #rescue Exception => msg
+      #	puts "-"*80
+      #	$log.fatal("Please report this error: #{msg}\n#{msg.backtrace.join("\n")}")
+      #	puts "-"*80
+      #  end
+    end
+
+    def thread_starting()
+      $threads=ThreadGroup.new()
+      $thread_list=Hash.new
+
+      if $config.port_mon
+        #thread to listen to monitored port & heartbeat host
+        add_monitoring_thread("Port monitoring", tmonitorport())
+      end
+      if $config.snmp_mon
+        #thread to listen to monitored snmp oid refs
+        add_monitoring_thread("Snmp monitoring", tmonitorsnmp())
+      end
+      if $config.wmi_mon
+        #thread to listen to monitored wmi refs
+        add_monitoring_thread("Wmi monitoring", tmonitorwmi())
+      end
+      if $config.custom_mon
+        #thread to listen to monitored custom cmd
+        add_monitoring_thread("Custom monitoring", tmonitorcustom())
+      end
+      if $config.jmx_mon
+        #thread to listen to monitored jmx cmd
+        add_monitoring_thread("JMX monitoring", tmonitorjmx())
+      end
+      if $config.broadcast_ping_state
+        #thread to find new host in local network with broacast ping	
+        add_monitoring_thread("Local ping", t_find_local_segment_pinging())
+	#thread to find new host in local segment sniffing for arp/lldp/dhcp packets
+	add_monitoring_thread("Local sniffing", t_find_local_segment_sniffing())
+        #thread to find new host in remote network with nmap ping
+        add_monitoring_thread("Remote ping", t_find_remote_new_host())	
+      end
+      if $config.mac_state
+        #thread to find MAC address
+        add_monitoring_thread("Find mac", tmacip())
+      end
+      if $config.node_resolving
+        #thread to resolv ip into name
+        add_monitoring_thread("Resolve ip to name", tresolvip())
+        #thread to resolve ip into netbios name
+        add_monitoring_thread("Resolve ip to netbios", tresolvnetbiosname())
+        #thread to find os with fingerprinting
+        add_monitoring_thread("Find os", tresolvos())
+      end
+
+      if $config.auto_save_map
+        add_monitoring_thread("Map autosaving", tauto_save_map())
+      end
+      $syslog_capture = SyslogCapture.new()
+      $snmptrap_capture = SnmpTrapCapture.new()
+      $im_daemon = XmppBot.new()
+      $irc_daemon = IrcBot.new()
+    end
+
+    def thread_stopping()
+      $threads.list.each {|thr|
+        Thread.kill(thr)
+        Gtk.thread_flush
+      }
+      #kill syslog daemon if needed
+      $syslog_capture.stop() unless $syslog_capture == nil
+      $snmptrap_capture.stop() unless $snmptrap_capture == nil
+      $im_daemon.stop() unless $im_daemon == nil
+      $irc_daemon.stop() unless $irc_daemon == nil
+    end
+
+    def busy?()
+       return $win.busy?()
+    end
+
+    def set_busy()
+       $win.busy()
+    end
+
+    def set_unbusy()
+       $win.unbusy()
+    end
+
+    def quit_now()
+      if !confirm_exit_window()
+        quit_all()
+      end
+    end
+
+    #
+    #	call all db method to save all the map in the db
+    #
+    def save_all_in_db()
+       #save nodes
+       set_busy()
+       Thread.start {
+	  $host.each_key {|ip|
+            $log.debug("Saving node host #{ip}")
+            nodeid=db_get_node_id(ip, HOSTNODE)
+	    db_set_mac(nodeid, $host[ip].mac)
+            db_set_node_type_and_os(nodeid, $host[ip].type, $host[ip].os)
+            db_set_node_position(nodeid, $host[ip].x, $host[ip].y)
+            db_set_severity(nodeid, $host[ip].status, $host[ip].avail_sev, $host[ip].snmp_sev, $host[ip].custom_sev,$host[ip].trap_sev,$host[ip].service_sev,$host[ip].wmi_sev,$host[ip].syslog_sev,$host[ip].jmx_sev)
+            db_set_map(nodeid, $host[ip].map)
+            db_set_name(nodeid, $host[ip].name, $host[ip].dns_name, $host[ip].dns_domain, $host[ip].netbios_name, $host[ip].netbios_domain)
+	    db_set_interfaces(ip, $host[ip].interface)
+	  }
+
+	  $network.each_key {|ip|
+            $log.debug("Saving node network #{ip}")
+            nodeid=db_get_node_id(ip,NETWORKNODE)
+            db_set_node_type_and_os(nodeid, $network[ip].type, $network[ip].os)
+            db_set_node_position(nodeid, $network[ip].x, $network[ip].y)
+            db_set_severity(nodeid, $network[ip].status, $network[ip].avail_sev, $network[ip].snmp_sev, $network[ip].custom_sev, $network[ip].trap_sev,$network[ip].service_sev,$network[ip].wmi_sev,$network[ip].syslog_sev,$network[ip].jmx_sev)
+            db_set_map(nodeid, $network[ip].map)
+            db_set_name(nodeid, $network[ip].name, Node::NONAME_PROPERTY, $network[ip].dns_domain, Node::NONAME_PROPERTY, $network[ip].netbios_domain)
+            db_set_node_size(nodeid, $network[ip].node_size)
+            if ip == ROOTMAPADDR
+              #make sure latest snmp read/write community have been stored
+              db_set_account(nodeid, "snmp", $config.read_community, $config.write_community)
+            end
+	  }
+
+	  #save links
+	  db_del_links()
+	  db_set_links()
+	  #unset cursor
+	  set_unbusy()      
+       }      
+    end
+
+    def quit_all
+      $config.write_config_yaml()
+      #kill threads
+      thread_stopping()
+      #stop event thread
+      $event_win.stop_analyzer()
+      #we need to save the nodes in db
+      save_all_in_db()
+      sleep(1) until !$win.busy?     
+      
+      if File.exists?(PID_FILE)
+         begin
+            File.delete(PID_FILE)
+	 rescue Exception => msg
+	    $log.error(msg)
+	 end
+      end
+      Syslog.close if Syslog
+      $win.destroy
+      Gtk.main_quit
+    end