#!/usr/bin/env python
# -*- coding: utf-8 -*-

from socket import socket, AF_INET, SOCK_STREAM
from time import localtime, asctime, time, sleep
import MySQLdb as db
from os import popen, path, setuid, setgid
from Queue import Queue
import codecs
import threading


HOST = ''
PORT = 79
LOGFILE = "/var/log/fingerd.log"
DBHOST = "localhost"
DBNAME = "geeky"
DBUSER = "fingerd"
DBPASS = "G3tInf0s4b0utMyS3lf"
DEFAULT = "__default__"
COMPUTER = "__computer__"
SPLITINFOS = "---"
PLANPATH = "/Users/planfiles"
THREADS = 5
QUERY = 1
ANSWER = 2


def debug(msg):
    if msg:
        print msg,

def openFiles():
    fileDict = {}
    fileDict['LOG'] = codecs.open(LOGFILE, encoding='utf-8', mode='a')
    planFilesProc = popen("ls -1 %s" % PLANPATH)
    for i in planFilesProc.readlines():
        fileDict[i.strip()] = codecs.open("%s/%s" % (PLANPATH, i.strip()), encoding='utf-8', mode='r')

    return fileDict

def closeFiles(files):
    for file in files.values():
        file.close()

def log(file, msg):
    entry = "[%s] %s\n" % (asctime(localtime()) , msg)
    try:
        file.write(entry)
    except:
        pass
    finally:
        debug(entry)

def sanitize(q):
    s = q.replace("_",
                    "\_")
    s = s.replace("%",
                    "\%")
    s = s.replace('"',
                    '\"')
    s = s.replace("'",
                    "\'")
    return s

def dbGet(query):
    conn = db.connect(host = DBHOST,
                      user = DBUSER,
                      passwd = DBPASS,
                      db = DBNAME )

    cursor = conn.cursor()
    if query == "":
        query="__computer__"

    q = sanitize(query)

    sqlq = "SELECT * FROM fingerd WHERE query = '%s'" % ((q))
    try:
        cursor.execute(sqlq)
        if cursor.rowcount == 0:
            sqlq = "SELECT * FROM fingerd WHERE query LIKE '%s%%'" % ((q))
            cursor.execute(sqlq)
        else:
            row = cursor.fetchone()
            return row[ANSWER]

    except:
        return dbGet(DEFAULT)

    if cursor.rowcount == 0:
        return dbGet(DEFAULT)
    elif cursor.rowcount == 1:
        row = cursor.fetchone()
        return row[ANSWER]
    elif cursor.rowcount > 1:
        rows = cursor.fetchall()
        ambiguous = "\"%s\" is ambiguous : \r\n" % (query)
        for row in rows:
            ambiguous += "\t%s \r\n" % (row[QUERY])

        return ambiguous

def planGet(query, files):
    for user in files.keys():
        if user.startswith(query):
            plan = files[user].read()
            files[user].seek(0)
            return plan
        else:
            return "No plan"

def treat(conn, addr):
    error = False
    answer = ""
    if not addr :
        data = "Port Scan"
        error = True
    else:
        try:
            data = conn.recv(512).decode("utf-8").lower()
        except:
            data = "Port scan"
            error = True

        if not data:
            data = "Port scan"
            error = True

        if len(data) > 40:
            data = "Overflow Try"
            error = True

        if error :
            conn.close()
            endLoop = True

        else:
            data=data.strip()
            log(files['LOG'], "%s -> %s" % (addr[0], data))

            answer = dbGet(data)
            if answer:
                answer+= "%s\n" % (SPLITINFOS)
            else:
                answer = ""

            answer+= planGet(data, files)

            if not answer:
                answer=dbGet(DEFAULT)
        if answer:
            endloop = True

    if not error:
       conn.sendall("%s\r\n" % (answer))
    conn.close()



class Server(threading.Thread):

    def __init__(self, recvqueue):
        self.__recvqueue = recvqueue
        threading.Thread.__init__(self)

    def run(self):
        while 1:
                # receive and treat
            item = self.__recvqueue.get()
            if item != None:
                conn, addr = item
                treat(conn, addr)
            else:
                # wait
                sleep(THREADS)



##############################################################################
#

s = socket(AF_INET, SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(THREADS)
files = openFiles()

setgid(42)
setuid(42)

recvQueue = Queue(THREADS)

for i in xrange(THREADS):
    Server(recvQueue).start()
    sleep(1)

while True:
    recvQueue.put( s.accept() )