central/em_server.rb

#!/usr/bin/env ruby

require 'eventmachine'
require 'digest/md5'
require 'fiber'
require 'geoip'
require 'socket'



# .. allowed commands .. ROLES = CAPABILITIES
# normal users have ROLE broadcast. Roles are defined on a per-user basis .. in a config.

$version = "0.2EventMachineSocketServer"
$debug = 0

$role_commands = Hash[
  #noinspection RubyStringKeysInHashInspection
  'everyone' => %w(PING WHO C PART),

  'broadcast_admin' => %w(BC_ID BC BC_ENDCOUNT),
  'broadcast' => %w(REQ_BC BC_RE),
	
	'specbot_admin' => %w(REQ_ASSIGN REQ_UNASSIGN REQ_PING REQ_ASSIGNMENTS),
	'specbot' => %w(ASSIGN_RE UNASSIGN_RE PING_RE ASSIGNMENTS_RE),
]

$default_role = "everyone"

# which role is talking to which role?
# effectively it says: this (local) command is sent to that (remote) topic .. that certain topic is read by that user with that role.
$role_dialogs = Hash[
  #noinspection RubyStringKeysInHashInspection
	'everyone' => %w(everyone),
	
	'broadcast_admin' => %w(broadcast),
	'broadcast' => %w(broadcast_admin),
	
	'specbot_admin' => %w(specbot),
	'specbot' => %w(specbot_admin),
	]

$user_roles = Hash[
  #noinspection RubyStringKeysInHashInspection
	'paul_dev_eggdrop' => %w(everyone broadcast),
	'paul_eggdrop' => %w(everyone broadcast),
	
	'paul_dev_specbot' => %w(everyone broadcast specbot),
	'paul_specbot' => %w(everyone broadcast specbot),
	
	'qw.nu' => %w(everyone broadcast),
	'qw.nu_poster' => %w(everyone broadcast),
	
	'mihawk_dev_specbot' => %w(everyone broadcast specbot),
	'mihawk_specbot' => %w(everyone broadcast specbot),
	
	'central_brain' => %w(everyone broadcast_admin specbot_admin),
]

$qw_server = Hash.new

def string2bytearray(text)
  return_array = Array.new
  text.each_byte{
    |b|
    return_array.push(b)
  }
  return_array
end

def qwstatus(iphost, ipport)
  udp_payload = [0xFF, 0xFF, 0xFF, 0xFF]
  udp_payload.concat(string2bytearray("status 23"))
  udp_payload.concat([0x0a]) # linefeed at the end

  udp_payload = udp_payload.pack("C*")
  #p udp_payload

  u2 = UDPSocket.new
  u2.send(udp_payload, 0, iphost, ipport)
  the_return = u2.recv(1500)
  u2.close

  put_log "muh #{the_return}"
  if the_return =~ /\W\W\W\Wn\\(.+)$/
    line = $1
    put_log "line #{line}"
    matches = line.scan(/(.+?)\\(.+?)(\\|$)/)

    the_hash = Hash.new
    matches.each {
      |k, v, _|
      the_hash[k] = "#{v}"
    }
    return the_hash
  else
    return false
  end

end


module HandleQwStatus
  attr_accessor :received

  def received
    puts "lol: #{@data}"
    @data
  end
  def receive_data(data)

    puts "lal: #{data}"
    @data = data

    self.received
  end
end

module CentralProtocolHandler
	
	@@connected_clients = Array.new
	@@broadcasts = Hash.new

	# default method that is being run on connection!
	def post_init # connection of someone starts here...
		@username = nil
	end


	### getters
	def entered_username?
		!@username.nil? && !@username.empty? # then it's true
	end

	def username
		@username
	end

	def my_roles
		$user_roles[@username]
	end

	def my_cmds
		my_roles.collect {|v| $role_commands[v]}.flatten
	end

	# returns online users by default by searching through saved connections
	def ousers
		users = Array.new
		@@connected_clients.each {|c| users.push(c.username)}

		users
	end # of ousers

	### checkers
	def allowed_cmd(inputmessage)
		my_cmds.each{|c|
			#print "A #{c} B #{inputmessage}\n"
			if inputmessage =~ /^#{c}/
				return true
			end
		}

		false
	end

	def online(user)
		if ousers.include? user
			true
		else
			false
		end
	end



	### actions
	def put_log(msg)
		puts "#{Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")}: #{msg}"
	end

	# searches through our hash of saved connections and writes them a messages.
	def	write_user(input, username = nil)
		if username.nil? || username.empty?
			username = @username
		end
		if @@connected_clients.find { |c| c.username == username }
      connection = @@connected_clients.find { |c| c.username == username }
      sometime = "#{Time.now.utc.strftime("%Y-%m-%d %H:%M:%S %z")}"
			line = "#{sometime}: #{input}\n"
			connection.send_data line
		end
	end # of write_user

	# searches through roles and writes those users on their connections
	def write_role(role, input, *exempts)
		#find users with role
		users = Array.new
		$user_roles.each {|k, v|
		                 if v.include? role
			                 users.push(k)
		                 end
		                 }

		# find users that are online and inside Array "users"
		lala = Array.new
		users.each {|v|
		           if ousers.include? v
			           lala.push(v)
		           end
		           }

		# now write to them
		lala.each {|user|
		          if not exempts.include? user
			          write_user(input, user)
		          end
		          }
	end	# of write_role()



	# what happens with what input?!
	def inputting(input)

		write_user("SYS You typed: #{input}")

		if input =~ /^([A-Z_]+)/
			cmd = $1
		end
		# now we have the cmd .. or not ;)

		if input =~ /^[A-Z_]+ (.+)/
			payload = $1
		end
		# now we can use payload

		if allowed_cmd(cmd)

			### typical system commands follow
			if cmd == "PING"
				write_user("PONG")

			elsif cmd == "C"

				if payload =~ /^(.+)$/
					write_role($default_role, "C #{@username}: #{$1}")

				else
					write_user("SYS Format is C <chattext>")
				end

		  elsif cmd == "WHO"
				ousers.each {|ouser| write_user("WHO_RE #{ouser} ROLES: #{$user_roles[ouser].join(", ")}")}


			elsif cmd == "PART"
				write_user("SYS Goodbye '#{@username}'.")
				write_role($default_role, "PARTED User '#{@username}' just left the party.", @username)
				return "bye"

			###now for the good stuff, broadcasting
			elsif cmd == "REQ_BC"

				# help with format .. but send the raw payload
				if payload =~ /^(.+),(.+),(.+),'(.+)','(.+)'$/
					#              n    f    s     ni     txt
					error = 0
					# $&
					# The string matched by the last successful pattern match in this scope, or nil if the last pattern match failed. (Mnemonic: like & in some editors.) This variable is r
					network = $1
					freqname = $2
					source = $3
					nickname = $4
					text = $5

					if not network =~ /^(QWalt)|(QDEV)/
						write_user("SYS Network name #{network} is unknown: QWalt or QDEV allowed.")
						error = 1
					end

					if not freqname =~ /^(-qw-)|(-spam-)|(-dev-)/
						write_user("SYS Frequency name is unknown #{freqname}")
						error = 1
					end

					if source =~ /^(#.+)|(qw:\/\/)|(http:\/\/)/

          else
						write_user("SYS Source string is not in the form ^(#.+)|(qw:\/\/)|(http:\/\/)  was: #{source}")
						error = 1
					end

					if not nickname =~ /^.+/
						write_user("SYS Nickname string is not in the form ^.+  #{nickname}")
						error = 1
					end

					if not text =~ /^.+/
						write_user("SYS Message string is not in the form ^.+ #{text}")
						error = 1
					end

				else # of check syntax
					write_user("SYS Command format is REQ_BC <network>,<frequency>,<source/channel>,'<nickname>','<message>'")
					error = 1
				end

				if error == 0

					# send REQ_BC to the corresponding role.
					bcid = Digest::MD5.hexdigest("%d %s %s %s %s %s" % [Time.now.utc.to_i, network, freqname, source, nickname, text])

					# so it only reaches the issuer of REQ_BC
					write_user("BC_ID #{bcid} for: #{network},#{freqname},#{source}")
					@@broadcasts[bcid] = @username

          # qw:// ip resolving
          if source =~ /^qw:\/\/(.+):(\d+)(.*)$/
            # ip address is 15 in length
            iphost = $1
            domainname = iphost # set a default
            ipport = $2
            rest = $3

            if iphost =~ /^\d+\.\d+\.\d+\.\d+/

              # find country code
              c = GeoIP.new('GeoIP.dat').country(iphost)[3].to_s.downcase
              rest.prepend " #{c}" unless c.nil? || c.empty?

              # get hostname from a qw status packet! perhaps there's a DNS name inside, which we can use! fixme
              hum = qwstatus(iphost, ipport)
              p hum
              if hum["hostname"] =~ /([\w\.]{3,}\.\w{2,4})/
                hostnamedns = $1
                ip_of_hostnamedns = Resolv.getaddress(hostnamedns)

                if ip_of_hostnamedns && (ip_of_hostnamedns == iphost)
                  # ok, we take it.
                  put_log "ok, we take #{hostnamedns} for #{iphost} here.."
                  domainname = hostnamedns
                end

              else
                # resolve it to a dns name
                resulting_name = Resolv.getname(iphost)
                if resulting_name
                  # if the resulting dns name...
                  # .. is too long, use ip-address instead.
                  # .. has too many dots, use ip-address instead.
                  # .. has too many numbers, use ip-address instead.
                  if resulting_name.length > 21 || resulting_name.split(".").size > 3 || resulting_name.scan(/\d/).size > 3
                    put_log "cutting down host_name: #{resulting_name}, because:"
                    put_log "#{resulting_name.length}"
                    put_log "#{resulting_name.split(".").size}"
                    put_log "#{resulting_name.scan(/\d/).size}"
                  else
                    domainname = resulting_name
                  end
                end # of resolving
              end

            end # if ip is x.x.x.x

            source = "qw://#{domainname}:#{ipport}#{rest}"
          end # of if source qw://x.x.x.x:portzzz

          # resolve
					finalmessage = "BC %s %s,%s,%s,'%s','%s'" % [bcid, network, freqname, source, nickname, text]
					write_role("broadcast", finalmessage, @username) # write to the role with the exempt of myself.


				end
				#end of REQ_BC here..

			elsif cmd == "BC_RE"

				if payload =~ /^(.+) (.+)=(\d+),(.+)=(\d+)$/

					bcid = $1
					user_string = $2
					user_count = $3
					item_string = $4
					item_count = $5

					payload = "%s %s=%d,%s=%d" % [bcid, user_string, user_count, item_string, item_count]
					# according bcid it is possible to get the originating user.. so send only to his topic!

					if @@broadcasts[bcid]
						to_user = @@broadcasts[bcid]

						write_user("SYS Broadcast reply bcid: #{bcid} underway to #{to_user}.")
						write_user("#{cmd} #{payload}", to_user)
					else
						write_user("SYS Broadcast reply bcid: #{bcid} underway.")
						write_role("broadcast", "#{cmd} #{payload}", @username)
					end

				else # of bc_re format check
					put_log "SYS Format is BC_RE <bcid> <userstring>=<usercount>,<itemstring>=<itemcount>"
				end

			end


		else  # of if allowed command
			write_user("SYS Command #{input} not allowed, your commands are: #{my_cmds.join(", ")}.")
		end  # of if allowed command

	end # of inputting!



	# default method that is being run on receiving data!
	def receive_data(data) # connection receives a line on the server end

    line = data.chomp unless data.chomp.nil?

    if line


      if entered_username? # oh, it's a known user

        # it's alive! kill ping timer, set a new one:
        if @ping_timer
          EventMachine.cancel_timer(@ping_timer)
        end
        @ping_timer = EventMachine.add_periodic_timer 90, proc { write_user("PING alive?") }

        # work on input
        inputter = inputting(line)
        if inputter == "bye"
          close_connection
        end

      else # of username known, then it seems to be the first connect

        # and this line is the user name coming in!
        username = line

        if online(username)
          put_log "SYS User '#{username}' tried to double connect. Say bye bye."
          send_data "SYS Hey '#{username}', only one connection allowed. Bye.\n"
          EventMachine.add_timer 1, proc {
            write_user("PING check forced", username)
            close_connection
          }

          return false
        end

        if $user_roles.any? {|k| k.include? username}
          @username = username
          @@connected_clients.push(self)
          @ping_timer = EventMachine.add_periodic_timer 90, proc { write_user("PING alive?") }
          # starting a pinger

          put_log("SYS '#{@username}' connected. Online now: #{ousers.join(", ")}")

          write_user("HELLO Hi user '#{@username}'! How are you? I'm '#{$version}'")
          write_user("ROLES #{my_roles.join(", ")}")
          write_user("COMMANDS #{my_cmds.join(", ")}")
          write_role($default_role, "JOINED User '#{@username}' just joined the party.", @username)
        else
          put_log "SYS User '#{username}' unknown to me. Saying bye."
          send_data "SYS User '#{username}' unknown to me. Bye.\n"

          # disconnect him
          close_connection
        end

      end # of username known
    end # of line

	end

	# default method that is being run on disconnection!
	def unbind # a connection goes bye bye
		if @username
			@@connected_clients.delete(self)
      if @ping_timer
        EventMachine.cancel_timer(@ping_timer)
      end

			put_log "SYS '#{@username}' disconnected."
		end
    put_log "SYS Online users now: #{ousers.join(", ")}"

	end
end



def main
	# #run: Note that this will block current thread.
	EventMachine.run do
    EventMachine.start_server("0.0.0.0", 7337, CentralProtocolHandler)
  end

end

main