path: root/src/moo/moo

#! /usr/bin/env python2.2

import os
import sys
import time
import signal

CONFDIR="/tmp/moo"

class Config:
    pass

def die(code, msg):
    sys.stdout.write(msg + "\n")
    sys.edit(code)
    
def printUsage():
    print "Usage: moo <options> [command] <command-options>\n" + \
              "Where [command] is one of:\n" + \
              "scan     - scan for available networks\n" + \
              "list     - list available profiles\n"+ \
              "select   - select a particular profile\n"

def scanNetworks():
    pass

def runCmd(cmd):
    if Config.verbosity > 5:
        print "Executing \"" + cmd + "\""
    v = os.system(cmd)
    if Config.verbosity > 5:
        print "Result: " + str(v)
    return v

class ProfileHandler:
    def __init__(self):
        self.profiles = {}
        self._loadProfiles()
    def _loadProfiles(self):
        for x in os.listdir(CONFDIR+"/profiles"):
            if x[-1] != "~" and x[0] != ".":
                self.profiles[x] = Profile(CONFDIR+"/profiles/"+x)
    def listProfiles(self,detailed=0):
        for x in self.profiles.keys():
            if detailed:
                print x + ":"
                self.profiles[x].dump()
            else:
                print x + " [" + self.profiles[x].description + "]"
    def getProfileNames(self):
        return self.profiles.keys()
    def getProfile(self,name):
        return self.profiles[name]


class Profile:
    def __init__(self, filename):
        self._loadFromFile(filename)
    def _loadFromFile(self,filename):
        self.desc = ""
        self.ifaceName = ""
        self.ip = ""
        self.broadcast = ""
        self.gateway = ""
        self.exclusive = "no"
        self.netmask = ""
        self.nameserver = ""

        ins = open(filename)
        for s in ins.readlines():
            for x in ["description","ifaceName","ip","broadcast",
                      "gateway","exclusive","nameserver","wepkey"]:
                if s.find(x+"=") == 0:
                    val=s.replace(x+"=","").strip()
                    self.__dict__[x] = val
    def dump(self):
        print "description = " + self.description + "\n" + \
              "iface       = " + self.ifaceName + "\n" + \
              "ip          = " + self.ip + "\n" + \
              "broadcast   = " + self.broadcast + "\n" + \
              "gateway     = " + self.gateway + "\n" + \
              "gateway     = " + self.nameserver + "\n" + \
              "exclusive   = " + self.exclusive + "\n" 

class Interface:
    def __init__(self, name):
        self.name = name
        self.netmask = ""
        self.broadcast = ""
        self.ip = ""
        self.gateway = ""
        self.nameserver = ""
        self.wepkey = ""
        self._loadIPV4Info()
    def _loadIPV4Info(self):
        pass
    def getNameserver(self):
        return self.nameserver
    def getNetmask(self):
        return self.netmask
    def getName(self):
        return self.name
    def getBroadcast(self):
        return self.broadcast
    def getWEPKey(self):
        return self.wepkey
    def getGateway(self):
        return self.gateway
    def setNameserver(self,nameserver):
        self.nameserver = nameserver
    def setIP(self, ip):
        self.ip = ip
    def setWEPKey(self,key):
        self.wepkey = key
    def setGateway(self,gw):
        self.gateway = gw
    def setBroadcast(self,broadcast):
        self.broadcast = broadcast
    def setNetmask(self,netmask):
        self.netmask = netmask
    def runDHCP(self):
        runCmd("dhcpcd " + self.name)
    def down(self):
        runCmd("ifconfig " + self.name + " down")
        pidFile = "/var/run/dhcpcd-" + self.name + ".pid"
        if os.path.exists(pidFile):
            ins = open(pidFile)
            pid = int(ins.readline())
            os.kill(pid,signal.SIGTERM)
            time.sleep(1)
    def up(self):
        options = ""

        if self.wepkey:
            if runCmd("iwconfig eth1 key " + self.wepkey):
              die(4, "Failed to set WEP key for " + self.name)
              
        if self.ip:
            options += self.ip + " "
        if self.broadcast:
            options += "broadcast " + self.broadcast + " "
        if self.netmask:
            options += "netmask " + self.netmask + " "

        if runCmd("ifconfig " + self.name + " " + options + " up"):
            die(2, "Failed to bring up " + self.name)
            
        if self.gateway:
            if runCmd("route add default gw " + self.gateway + " " + self.name):
                die(3, "Failed to set default gateway for " + self.name)
            
        if self.nameserver:
            if Config.verbosity > 5:
                print("Using nameserver " + self.nameserver)
            try: 
                ous = open("/etc/resolv.conf","w")
                ous.write("nameserver " + self.nameserver)
                ous.close()
            except OSError:
                die("Failed to set nameserver")
        if Config.verbosity > 3:
            print "Brough interface " + self.name + " up"
            
class InterfaceHandler:
    def __init__(self):
        self.ifaces = {}
        self._loadAllInterfaces()
    def _loadAllInterfaces(self):
        ins=open("/proc/net/dev")
        for line in ins.readlines():
            tokens = line.split(":")
            if len(tokens) > 1:
            	ifaceName = tokens[0].strip()
                iface = Interface(ifaceName)
                self.ifaces[ifaceName] = iface
    def getInterface(self,ifaceName):
        return self.ifaces[ifaceName]
    def downAll(self):
        for x in self.ifaces.values():
            if x.getName() != "lo":
                x.down()

class Moo:
    def __init__(self):
        self.profileHandler = ProfileHandler()
        self.ifaceHandler = InterfaceHandler()
    
    def selectProfile(self,profile):
        prof = self.profileHandler.getProfile(profile)

        if prof.exclusive == "yes":
            self.ifaceHandler.downAll()

        iface = self.ifaceHandler.getInterface(prof.ifaceName)
        
        if prof.ip == "dhcp":
            iface.runDHCP()
        else:
            iface.setIP(prof.ip)
            iface.setBroadcast(prof.broadcast)
            iface.setNetmask(prof.netmask)
            iface.setGateway(prof.gateway)
            iface.setNameserver(prof.nameserver)
            iface.up()
            
    def listProfiles(self,detailed=0):
        self.profileHandler.listProfiles(detailed)

def initConfig():
    Config.verbosity = 3
    
def main():

    initConfig()
    
    if len(sys.argv) < 2:
        printUsage()
        sys.exit(1)

    moo = Moo()

    for i in xrange(len(sys.argv)):
        if sys.argv[i] == "list":
            detailed = 0
            for x in sys.argv[i:]:
                if x == "--detailed":
                    detailed = 1
            moo.listProfiles(detailed)

        elif sys.argv[i] == "select":
            moo.selectProfile(sys.argv[2])

if __name__ == "__main__":
    main()


# TODO
# - automatically create profile
# - specify wireless network name
# - specify wep key
# - specify access point
# - specify pre_run/post_run commands
#   - with parameters
#