def bind(self):
	self.q = nfqueue.queue()
	self.q.open()
	self.q.bind(socket.AF_INET)
	self.q.set_callback(self.callback)
	self.q.create_queue(0)
	self.q.try_run()

def out_queue():
    """setup the NF_queue to "rule" the outgoing packets"""

    q = nfqueue.queue()
    q.open()

    # need to be done once
    # performed in In.py
    #q.unbind(AF_INET6)
    #q.bind(AF_INET6)


    q.set_callback(callback)

    q.create_queue(2)


    q.set_queue_maxlen(5000)

    # send a Router Solitication to all neighboring routers
    # (only at the launch of the program)
    if not NDprotector.is_router:
        SendRTSol()

    return q

 def start_dns_queue(self):
     self.q = nfqueue.queue()
     self.q.set_callback(self.nfqueue_callback)
     self.q.fast_open(0, socket.AF_INET)
     self.q.set_queue_maxlen(5000)
     reactor.addReader(self)
     self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)

    def fuzzThread(self, button, aFilter):
        self.log.info(_("Launching fuzzing process with : filter=\"{0}\"").format(aFilter.get_text()))

        ## Set Netfilter NFQUEUE
#        os.popen("sudo iptables -I OUTPUT -p tcp --dport 80  -j NFQUEUE 2>&1 > /dev/null")
#        os.popen("sudo iptables -I OUTPUT -p tcp --sport 80  -j NFQUEUE 2>&1 > /dev/null")
        q = nfqueue.queue()
        q.open()
        try:
            q.unbind(socket.AF_INET)
        except:
            pass
        q.bind(socket.AF_INET)
        q.set_callback(self.nfqueue_cb)
        q.create_queue(0)
        q.set_queue_maxlen(5000)
        try:
            ## TODO : do it in a dedicated process

            q.try_run()
        except:
            pass
        q.unbind(socket.AF_INET)
        q.close()

#        os.popen("sudo iptables -D OUTPUT -p tcp --dport 80  -j NFQUEUE 2>&1 > /dev/null")
#        os.popen("sudo iptables -D OUTPUT -p tcp --sport 80  -j NFQUEUE 2>&1 > /dev/null")
        gobject.idle_add(button.set_sensitive, True)

    def run(cls, template_path=''):

        # check if root
        if not os.geteuid() == 0:
            exit("\nPlease run as root\n")
        os_pattern = get_os_pattern(template_path)

        # Flush the IP tables first
        flush_tables()
        # Configure NFQUEUE target
        # Capture incoming packets and put in nfqueue 1
        os.system('iptables -A INPUT -j NFQUEUE --queue-num 0')

        # creation of a new queue object
        q = nfqueue.queue()
        q.set_callback(ProcessPKT(os_pattern).callback)
        q.fast_open(0, socket.AF_INET)
        q.set_queue_maxlen(-1)

        # process queue for packet manipulation
        try:
            workers = list()
            for i in range(2):
                workers.append(gevent.spawn(cls.worker, q))
            gevent.joinall(workers)
        except KeyboardInterrupt:
            # on exit clean up
            q.unbind(socket.AF_INET)
            q.close()
            flush_tables()
            print 'Exiting...'

    def run(self):
        q = nfqueue.queue()

        if self.verbose:
            print "NFQ: open"
        q.open()

        if self.verbose:
            print "NFQ: bind"
        q.bind(AF_INET)

        if self.verbose:
            print "NFQ: setting callback"
        q.set_callback(self.cb)

        if self.verbose:
            print "NFQ: creating queue"
        q.create_queue(self.queue)

        q.set_queue_maxlen(50000)

        if self.verbose:
            print "NFQ: trying to run"
        try:
            q.try_run()
        except KeyboardInterrupt, e:
            print "NFQ: interrupted"

	def go(self):
		self.q = nfqueue.queue()
		self.q.open()
		self.q.bind(socket.AF_INET)
		self.q.set_callback(self.filter_pkt)
		self.q.create_queue(0)
		self.q.try_run()

	def __init__(self, callback, nqueue=0, family=socket.AF_INET, maxlen=5000, map=None):
		self.queue = nfqueue.queue()
		self.queue.set_callback(callback)
		self.queue.fast_open(nqueue, family)
		self.queue.set_queue_maxlen(maxlen)
		self.fd = self.queue.get_fd()
		asyncore.file_dispatcher.__init__(self,self.fd,map)
		self.queue.set_mode(nfqueue.NFQNL_COPY_PACKET)

 def __init__(self):
     self.q = nfqueue.queue()
     self.q.set_callback(queue_cb)
     self.q.fast_open(0, socket.AF_INET)
     self.q.set_queue_maxlen(5000)
     reactor.addReader(self)
     self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)
     print '[*] Waiting for data'

 def nfq_setup(self, queueno):
   q = nfqueue.queue()
   q.set_callback(self.cb)
   try:
     q.fast_open(queueno, AF_INET)
   except RuntimeError, e:
     log.error("cannot bind to nf_queue %d: %s. Already in use or not root?" % (queueno, e))
     return False

	def __init__(self):
		self.q = nfqueue.queue()
		self.q.set_callback(Parser().start)
		self.q.fast_open(0, socket.AF_INET)
		self.q.set_queue_maxlen(5000)
		reactor.addReader(self)
		self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)
		print '[*] Flushed firewall and forwarded traffic to the queue; waiting for data'

 def __init__(self, cb, nqueue=0, family=AF_INET6, maxlen=5000, map=None):
     self._q = queue()
     self._q.set_callback(cb)
     self._q.fast_open(nqueue, family)
     self._q.set_queue_maxlen(maxlen)
     self.fd = self._q.get_fd()
     asyncore.file_dispatcher.__init__(self, self.fd, map)
     self._q.set_mode(NFQNL_COPY_PACKET)

 def __init__(self, args):
     self.q = nfqueue.queue()
     self.q.set_callback(Parser(args).start)
     self.q.fast_open(0, socket.AF_INET)
     self.q.set_queue_maxlen(5000)
     reactor.addReader(self)
     self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)
     print '[*] Flushed 防火墙 和转发流量 到队列 ; 等待数据 '

 def __init__(self):
     self.q = nfqueue.queue()
     self.q.set_callback(cb)
     self.q.fast_open(0, socket.AF_INET)
     self.q.set_queue_maxlen(5000)
     reactor.addReader(self)
     self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)
     print '[info] spoofing dns packets'

def setup_nfqueue(fct, num):
    q = nfqueue.queue()
    q.open()
    q.unbind(socket.AF_INET)
    q.bind(socket.AF_INET)
    
    q.set_callback(fct)
    q.create_queue(num)
    return q

	def __init__(self, cb, nqueue=1, family=AF_INET, maxlen=5000, map=None):
		self._q = nfqueue.queue()
		self._q.set_callback(cb)
		self._q.fast_open(nqueue, family)
		self._q.set_queue_maxlen(maxlen)
		self.fd = self._q.get_fd()
		asyncore.file_dispatcher.__init__(self, self.fd, map)
		self._q.set_mode(nfqueue.NFQNL_COPY_PACKET)
		print ' [*] Waiting for packets. To exit press CTRL+C'

	def __init__(self):
		print '[*] in queue started.. waiting for data'
		self._q = nfqueue.queue()
		self._q.set_callback(Own().handler)
		self._q.fast_open(0, socket.AF_INET)
		self._q.set_queue_maxlen(5000)
		self.fd = self._q.get_fd()
		asyncore.file_dispatcher.__init__(self, self.fd, None)
		self._q.set_mode(nfqueue.NFQNL_COPY_PACKET)

    def __init__(self, queue, callback):
        self.queue = nfqueue.queue()
        self.queue.set_callback(callback)
        self.queue.fast_open(queue, AF_INET)
        self.queue.set_queue_maxlen(1024)

        self.fd = self.queue.get_fd()
        asyncore.file_dispatcher.__init__(self, self.fd, None)

        self.queue.set_mode(NFQNL_COPY_PACKET)

 def __init__(self, callback, num):
     threading.Thread.__init__(self)
     self._q = nfqueue.queue()
     self._q.set_callback(callback)
     self._q.fast_open(num, AF_INET)
     self.fd = self._q.get_fd()
     asyncore.file_dispatcher.__init__(self, self.fd, None)
     self._q.set_mode(nfqueue.NFQNL_COPY_PACKET)
     
     self._stopevent = threading.Event()

 def run_queue_blocking(self, callback, num):
     q = nfqueue.queue()
     q.set_callback(callback)
     q.fast_open(num,AF_INET) #Instead of : q.open() and q.bind(socket.AF_INET) and q.create_queue(12)
     try:
         time.sleep(1)
         q.try_run()
     except:
         q.unbind(AF_INET)
         q.close()