Merge branch 'master' of ssh://git.ipfire.org/pub/git/oddments/cappie

[oddments/cappie.git] / cappie / events.py

#!/usr/bin/python
###############################################################################
#                                                                             #
# Cappie                                                                      #
# Copyright (C) 2010 Michael Tremer                                           #
#                                                                             #
# This program 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, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
###############################################################################

import os
import subprocess
import time

from constants import *
from errors import *

class Event(object):
	def __init__(self, interface):
		self.cappie = interface.cappie
		self.interface = interface
		self.log = interface.log
		self.db = self.cappie.db

	def __str__(self):
		return self.__class__.__name__

	def addEvent(self, event):
		return self.cappie.queue.add(event)

	def run(self):
		raise NotImplementedError


class EventShell(Event):
	heartbeat = 0.1
	timeout = 10

	def __init__(self, interface, script):
		Event.__init__(self, interface)

		self.script = script

	def run(self):
		args = " ".join([self.script, self.interface.dev])

		start = time.time()
		self.log.debug("Running: %s" % args)

		p = subprocess.Popen(args,
			close_fds=True,
			shell=True,
			stdin=open("/dev/null", "r"),
			stdout=subprocess.PIPE,
			stderr=subprocess.STDOUT)

		while p.poll() is None:
			time.sleep(self.heartbeat)
			if (time.time() - start) > self.timeout:
				try:
					os.killpg(p.pid, 9)
				except OSError:
					pass
				raise EventTimeout, "Script took too long to return"

		for line in p.stdout.read().splitlines():
			if not line: continue
			self.log.debug("  %s" % line)

		self.cappie.log.debug("Child process returned with exit code: %s" % \
			p.returncode)

		return p.returncode


class EventRequestTrigger(Event):
	def __init__(self, interface, packet):
		Event.__init__(self, interface)

		self.db = interface.cappie.db
		self.packet = packet

	def _updateAddress(self, mac, address):
		where = "WHERE mac = '%s' AND address = '%s'" % (mac, address)

		if self.db.get("SELECT * FROM addresses %s" % where):
			self.db.execute("UPDATE addresses SET lastseen='%d' %s" % \
				(time.time(), where))
		else:
			self.db.execute("INSERT INTO addresses VALUES('%s', '%s', '%d')" % \
				(mac, address, time.time()))

	def _updateChanges(self, *args):
		for arg in args:
			where = "WHERE address = '%s'" % arg
			if self.db.get("SELECT * FROM changes %s" % where):
				self.db.execute("UPDATE changes SET lastchange = '%d' %s" % \
					(time.time(), where))
			else:
				self.db.execute("INSERT INTO changes VALUES('%s', '%d')" % \
					(arg, time.time()))

	def run(self):
		mac = self.packet.source_address
		address = self.packet.source_ip_address

		self._updateAddress(mac, address)
		self._updateChanges(mac, address)


class EventResponseTrigger(EventRequestTrigger):
	pass


class EventGarbageCollector(Event):
	def __init__(self, db, log):
		self.db = db
		self.log = log

	def run(self):
		# Remove old addresses
		self.db.execute("DELETE FROM addresses WHERE lastseen >= '%d'" % \
			(time.time() - DB_LASTSEEN_MAX))

		self.db.commit()


class EventCheckDuplicate(Event):
	def __init__(self, interface, packet):
		Event.__init__(self, interface)
		self.packet = packet

	def run(self):
		entries = self.db.query("SELECT * FROM addresses WHERE address = '%s'" % \
			self.packet.source_ip_address)

		if not entries:
			return

		for entry in entries:
			if self.packet.source_address == entry.mac:
				entries.remove(entry)

		if len(entries) > 1:
			self.addEvent(EventHandleDuplicate(self.interface, self.packet))


class EventHandleDuplicate(Event):
	def __init__(self, interface, packet):
		Event.__init__(self, interface)
		self.packet = packet

	def run(self):
		self.log.warning("We probably have a mac spoofing for %s" % \
			self.packet.source_address)


class EventCheckFlipFlop(Event):
	pass