~nilsschlupp/auto-ndiswrapper/rewrite

#!/usr/bin/env python

#Auto-NDISwrapper by Nils Schlupp, Gabriel J. Perez and Richard Kaufman
#
#This program automatically looks at what Wi-Fi card you have, it disables any wireless driver currently installed, fetches #the correct Windows driver from the Internet and installs it with NDISwrapper.

#Copyright (C) 2007, 2008 Gabriel J. Perez <gabrieljoel@gmail.com>, Nils Schlupp <nils.schlupp@gmail.com> and Richard Kaufman <richardbkaufman@gmail.com>
#
#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 2 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, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

'''Auto-NDISwrapper -- Linux Wi-Fi as easy as it can get'''

__version__ = '0.1.1'

import os, platform, sys, re, subprocess, webbrowser, commands
import logging
from optparse import OptionParser

class NullHandler(logging.Handler):
	'''Define an empty logger'''
	def emit(self, record):
		pass


class UIDError(Exception):
	'''Raised when not run as root'''
	def __init__(self, message):
		self.message = message
		logger.debug(self.__str__())
	def __str__(self):
		return repr(self.message)


class ErternalProgramError(Exception):
	'''Raised when external program fails'''
	def __init__(self, message):
		self.message = message
		logger.debug(self.__str__())
	def __str__(self):
		return repr(self.message)


class BinaryNotFound(Exception):
	'''Raised when ndiswrapper binary not found'''
	def __init__(self, message):
		self.message = message
		logger.debug(self.__str__())
	def __str__(self):
		return repr(self.message)


class DatabaseNotFound(Exception):
	'''Raised when database file not found'''
	def __init__(self, message):
		self.message = message
		logger.debug(self.__str__())
	def __str__(self):
		return repr(self.message)


class ConnectionFailed(Exception):
	'''Raised when connection to server could not be established'''
	def __init__(self, message):
		self.message = message
		logger.debug(self.__str__())
	def __str__(self):
		return repr(self.message)


class AUTO_NDIS(object):
	'''Primary auto-ndiswrapper class'''
	
	def __init__(self):
		#sys.path.append(os.getcwd())
		self.logger = logging.getLogger("AUTO-NDIS MAIN")

		
	def perform_initial_checks(self):
		'''Check for root privileges and ndiswrapper binary'''
		self.logger.debug('Starting perform_initial_checks')
		##If the user isn't root the program will quit
		if os.geteuid() != 0 and not opts.nocheck:
			raise UIDError('Not run as root!')
		
		##If the user doesn't have ndiswrapper installed the program will quit
		if not os.path.exists(opts.ndiswrapper_bin) and not opts.nocheck:
			raise BinaryNotFound('Ndiswrapper Binary not found')
		
		self.logger.debug('Done perform_initial_checks')


	def get_card_id(self):
		'''Gets the wireless card's id number and revision number.'''
	
		self.logger.debug('Starting get_card_id')
		
		##Gets the id of all the pci devices
		outtext, retcode = self.getoutput('lspci', '-n')
		
		#if retcode != 0:
			#raise ExternalProgramError('lspci -n')
		##Stores the pci ids with the revision number in a list
		pci = self.process_pciids(outtext)
	
		##Gets the id of all the usb devices
		outtext, retcode = self.getoutput('lsusb')
		
		#if retcode != 0:
			#raise ExternalProgramError('lsusb')
		##Stores the usb ids in a list
		usb = self.process_pciids(outtext)
		
		return pci, usb
		
		##Checks if the user has a pci card or a usb card, if he has both the program will ask card he wants to setup
		##If he has neither the program will exit and tell him what pci card he has if he has one
		#if pcicard != 'empty' and usbcard == 'empty':
			#return pcicard
	
		#elif pcicard == 'empty' and usbcard != 'empty':
			#return usbcard
	
		#elif pcicard != 'empty' and usbcard != 'empty':
			#choice = raw_input('Setup (w)ificard or setup your (u)sbcard?: ')
	
			#while choice != 'W' and choice != 'w' and choice != 'U' and choice != 'u':
				#print 'Please try again'
				#choice = raw_input('Setup (w)ificard or setup your (u)sbcard?: ')
			#if choice == 'W' or choice == 'w':
				#return pcicard
			#elif choice == 'U' or choice == 'u':
				#return usbcard
			#else:
				#return get_card_id()
	
		#elif pcicard == 'empty' and usbcard == 'empty':
			#print 'Sorry, card not yet supported by Auto-NDISwrapper'
			#print 'Save this output as it will help other people give you support'
			#get_print_card_info()
			#sys.exit(1)
	
	def get_lists(self,pci,usb):
		pcilist = usblist = None
		
		# Try getting info from server
		if opts.repo == 'auto' or opts.repo == 'remote':
			try:
				pcilist = self.serverquery(pci)
				usblist = self.serverquery(usb)
			except ConnectionFailed:
				logger.error('Failed to connect to server')
				if opts.repo == 'auto':
					logger.error('Trying local database')
		
		# If we have nothing, either fail or try the local reposotory
		if pcilist == None and usblist == None:
			if opts.repo == 'remote':
				raise ConnectionFailed('Unable to establish connection. Please either check your interent connection or download the local database from FIXME...')
		
		
			pcilist = self.localquery(pci)
			usblist = self.localquery(usb)
		
		return pcilist, usblist
	
	
	def process_pciids(self, output):
		logger.debug('Starting process_pciids')
		output = output.split("\n")
		rev = None
		pciid = None
		for i in output:
			i=i.split(' ')
			if len(i) > 5:
				try:
					pciid = i[5]
				except:
					pciid = None
			else:
				try:
					pciid = i[2]
				except:
					pciid = None
				try:
					rev = i[4][:2]
				except:
					rev = None
			
			try:
				pci.append([pciid,rev])
			except:
				pci=[[pciid,rev]]
		
		logger.debug('Done process_pciids')
		return pci
		
	def serverquery(self, list):
		'''Queries the server for the information on the local pciids'''
		logger.debug('Starting serverquery')
		raise ConnectionFailed('Server query to be implemented')
		
		logger.debug('Done serverquery')

	def localquery(self, devices_list, database):
		'''Looks if one of the ids in the devices list given as argument matches an entry in the database'''
		
		logger.debug('Starting localquery')
		matches = None
		f = open(database)
		for line in f:
			line = line.split(';;;')
			for pci in devices_list:
				if line[0].strip() == pci[0]:
					if line[1].strip() == pci[1]:
						try:
							matches.insert(0,line)
						except:
							matches = [line]
					else:
						try:
							matches.append(line)
						except:
							matches = [line]
							
		f.close()
		logger.debug('Done localquery')
		return matches

	def selectdatabase(self, selection = None):
		#find database file:
		# 1 check cwd
		incwd = os.listdir(os.getcwd())
		# 2 check dir with auto-ndis.py file
		inprogramdir = os.listdir(os.path.split(os.path.abspath(sys.argv[0]))[0])
		# 3 check the tmp_dir folder
		intmpdir = os.listdir(opts.tmp_dir)

		databases = []
		
		for i in inprogramdir:
			if 'database' in i:
				if i == 'database':
					databases.insert(0,os.path.split(os.path.abspath(sys.argv[0]))[0] + '/' + i)
				else:
					databases.append(os.path.split(os.path.abspath(sys.argv[0]))[0] + '/' + i)
		
		for i in incwd:
			if 'database' in i:
				if i == 'database':
					databases.insert(0,os.getcwd() + '/' + i)
				else:
					databases.append(os.getcwd() + '/' + i)
		
		for i in intmpdir:
			if 'database' in i:
				if i == 'database':
					databases.insert(0,opts.tmp_dir + '/' + i)
				else:
					databases.append(opts.tmp_dir + '/' + i)
		
		if len(databases) == 0:
			raise DatabaseNotFound('No database found anywhere')
		
		if len(databases) > 1:
			return databases
		
		if len(databases) == 1:
			return databases[0]
			
		raise Exception('WTF happened???')
		
	def getoutput(self,*cmd):
		'''Like commands.getoutput, but uses subprocess. It also returns the return code of the process.'''
	
		myproc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
		value  =  myproc.stdout.read()
		retcode = myproc.wait()
		return value, retcode
	
	def get_print_card_info(self):
		'''
		Prints the pci id and other information about the pci wireless cards.
		'''
	
		output, retcode = getoutput('lspci')
		lines = output.split('\n')
	
		for line in lines:
			if 'Network controller' in line:
				card_data = line
				break
	
		if card_data:
			card_info = card_data[28:len(card_data)]
			print card_info
		else:
			print 'No Network Devices Found!'
	
	def check_for_internet(self):
		'''Pings google to see if the user has an internet conecction available.'''
	
		print '\n[*] Looking if an Internet connection is available, this may take a few seconds'
	
		test, retcode = getoutput('ping', '-c', '1', 'google.com')
	
		if 'unknown host' in test:
			print '[ERROR] An Internet connection was not found'
			choice = raw_input('(C)ontinue, (R)etry, (O)ffline mode or (E)xit: ')
	
			if choice == 'C' or choice == 'c':
				pass
	
			elif choice == 'R' or choice == 'r':
				return check_for_internet()
	
			elif choice == 'O' or choice == 'o':
				manualmode()
				installdriver()
				installation_report()
				sys.exit(1)
	
			elif choice == 'E' or choice == 'e':
				sys.exit(1)
	
			else:
				return check_for_internet()
	
		else:
			print '[*] Internet connection found, continuing installation'
	
	def remove_old_drivers(self):
		'''Removes existing wireless drivers.'''
		print '[*] Removing Old Drivers:'
		baddrivers = yourcard_dic['blacklist']
		if baddrivers in getoutput('lsmod| awk "{print $1}"'):
			print '   removing %s' % (baddrivers, )
			subprocess.call(['rmmod', baddrivers])
		else:
			print '   Drivers not loaded, nothing to remove'
	
	def blacklist_drivers(self):
		'''Blacklists existing wireless drivers.'''
	
		print '[*] Blacklisting:'
		baddrivers = yourcard_dic['blacklist']
	
		if any(baddrivers in line.split('#')[0] for line in open('/etc/modprobe.d/blacklist')):
			print '   driver already blacklisted, skipping'
		else:
			print '   writing to /etc/modprobe.d/blacklist'
			blacklist = open('/etc/modprobe.d/blacklist', 'a')
			blacklist.write('\n#%s' % (baddrivers, ))
			blacklist.close()
	
	def print_driver_license(self):
		'''
		Checks if the user agrees with the driver's EULA.
		'''
	
		print 'Do you agree with this proprietary driver\'s End User License Agreement? You can find it in the website of your card\'s manufacturer.'
		choice = raw_input('(Y)es or (N)o, if you don\'t agree the program will quit: ')
	
		if choice == 'Y' or choice == 'y':
			pass
	
		elif choice == 'N' or choice == 'n':
			sys.exit(1)
	
		else:
			return driver_license()
	
	def create_auto_ndis_folder(self):
		'''Creates a folder in which place the downloaded drivers.'''
	
		try:
			os.makedirs('%s/%s' % (opts.tmp_dir, card_id, ))
			print 'Tmpdir created'
			os.chmod(opts.tmp_dir,0777)
			os.chdir('%s/%s' % (opts.tmp_dir, card_id, ))
		except:
			if os.path.exists('%s/%s' % (opts.tmp_dir, card_id, )):
				print '\nTmpdir exists and ok, continuing'
				os.chdir('%s/%s' % (opts.tmp_dir, card_id, ))
			else:
				print '[ERROR] can\'t create tmpdir'
				print '   Either specify an alternative or ensure that /tmp is writable and not full'
				sys.exit(1)
	
	def find_decompression(self):
		'''Determines the right decompression program to be used with the downloaded driver.'''
	
		decompression = 'manual'
	
		if '.exe' in url or '.zip' in url:
			decompression = 'unzip'
	
		elif '.tar' in url:
			decompression = 'tar -vvf'
	
		elif '.tar.gz' in url:
			decompression = 'tar -xvvzf'
	
		elif '.tar.bz2' in url:
			decompression = 'tar -xvvjf'
	
		elif '.cab' in url:
			decompression = 'cabextract'
	
		elif '.rar' in url:
			decompression = 'unrar'
	
		if decompression != 'manual':
			#Checks if the system has the necessary decompression program
			test = commands.getoutput(decompression)
			if 'not found' in test:
				print '[ERROR] The program to extract %s files is not installed in your system' % (decompression, )
				print 'Install a program on your system to extract %s files and then rerun the script' %(decompression, )
				sys.exit(1)
		return decompression
	
	def fetch(self):
		'''Downloads the apropiate driver.'''
	
		print '[*] Downloading driver now from "%s"' % (url, )
		if (opts.quiet):
			retcode = subprocess.call(['wget', url, '-qO ', opts.tmp_dir + '/' + card_id + '/' + driver, '-o ', opts.tmp_dir + '/' + card_id + '/' + 'wget.log'])
		else:
			retcode = subprocess.call(['wget', url, '-O ', opts.tmp_dir + '/' + card_id + '/' + driver, '-o ', opts.tmp_dir + '/' + card_id + '/' + 'wget.log'])
	
	
		if retcode != 0:
			print '[ERROR] Download unsuccessfull, please check your Internet conecction and wget.log in your tmpdir for errors.'
			if (opts.debug):
				print '[DEBUG] wget returned code: %s' % (retcode, )
			sys.exit(1)
	
	def extract(self, decompression):
		'''Extracts the dowloaded driver.'''
	
		print '[*] Extracting driver'
	
		if (opts.debug):
			print '[DEBUG] Decompression method: %s' % (decompression, )
	
		retcode = subprocess.call([decompression, opts.tmp_dir + '/' + card_id + '/' + driver])
	
		if retcode != 0:
			print '[WARNING] Decompression may have failed'
	
			if (opts.debug):
				print '[DEBUG] Decompression method returned code: %s' % (retcode, )
	
			choice = raw_input('(C)ontinue, (R)etry, (S)pecify different decompression method or (E)xit: ')
	
			if choice == 'C' or choice == 'c':
				pass
	
			elif choice == 'R' or choice == 'r':
				return extract(decompression)
	
			elif choice == 'S' or choice == 's':
				divided_url = url.split('.')
				file_type = divided_url[len(divided_url)-1]
				decompression = raw_input('Enter command to decompress %s files: ' % (file_type, ))
				return extract(decompression)
	
			elif choice == 'E' or choice == 'e':
				sys.exit(1)
	
			else:
				return extract(decompression)
	
	def manualmode(self):
		'''Comes into play if the user doesn't have an internet connection or if the driver need to be fetched manually.'''
	
		print '\nThe driver needs to be fetched manually from: %s' % (url, )
		print 'Please place the "%s" file, along with the .sys files into:' % (driver, )
		print '%s/%s' % (opts.tmp_dir, card_id, )
		webbrowser.open_new(url)
	
		while not any(driver in line for line in os.listdir('%s/%s/' % (opts.tmp_dir, card_id, ))):
			try:
					dummy = raw_input('When you have succesfully dowloaded the driver and extracted it press <Enter>: ')
	
			except:
				##Executed when CTRL + C is pressed.
				print '\n\nCanceled!\n'
				sys.exit(1)
	
		print '\nDriver file found! Continuing installation.'
	
	def installdriver(self):
		'''Installs the driver with NDISwrapper.'''
	
		if driver == '.inf':
			inf_files, retcode = getoutput('find', opts.tmp_dir + '/' + card_id, '-type', 'f', '-name', '*.inf')
			inf_files = inf_files.split('\n')
			inf_file = inf_files[0]
			print '\nA driver has not been specified yet for this card, will attempt procedure with the first found driver in %s/%s: %s' % (opts.tmp_dir, card_id, inf_file)
	
		else:
			inf_file, retcode = getoutput('find', opts.tmp_dir + '/' + card_id, '-type', 'f', '-name', driver)
	
		create_log_file(inf_file)
	
		if ( opts.debug ):
			print '[DEBUG] Driver found at %s' % (inf_file, )
	
		#Attempt to install driver
		output, retcode = getoutput('ndiswrapper', '-i', inf_file)
	
		#Attempt to detect errors
		if 'already' in output:
			print '\nDriver is already installed'
			pass
	
		elif retcode != 0:
			print '[ERROR] Driver installation failed'
			if (opts.debug):
				print '[DEBUG] NDISwrapper returned code: %s' % (retcode, )
			pass
	
		else:
			##Assume driver installed successfully and then set up and reload the module
			subprocess.call(['ndiswrapper',  '-ma'])
			subprocess.call(['modprobe', '-r', 'ndiswrapper'])
			subprocess.call(['modprobe', 'ndiswrapper'])
			print 'Installation finished'
			pass
	
	def create_log_file(self, driver):
		'''Creates a simple log file with some useful info.'''
	
		log = open('autondis-log.txt', 'w')
	
		os_info = os.uname()
		distribution = platform.dist()
		ndis_version, retcode = getoutput('ndiswrapper', '-v')
	
		log.write('OS and date = ')
		for item in os_info:
			log.write(item)
	
		log.write('\nDistribution = ')
		for item in distribution:
			log.write(item)
	
		log.write('\nNDISwrapper info = ')
	
		for item in ndis_version:
			log.write(item)
	
		log.write('\nID = %s \n' % (card_id, ))
		log.write('URL = %s \n' % (url, ))
		log.write('DRIVER = %s \n' % (driver, ))
	
		log.close()
	
	def installation_report(self):
		'''Prompts the user to report the installation if it was succesful.'''
	
		output, retcode = getoutput('ndiswrapper', '-l')
		print '\n' + 'NDISwrapper output: ' + '\n' + output
	
		print 'Is your wireless connection working now with NDISwrapper thanks to this script?'
		choice = raw_input('(Y)es and I would like to help this project by reporting my installation manually trough www.easylinuxwifi.org, (N)o it did not work for me: ')
	
		if choice == 'Y' or choice == 'y':
			print '\nPlease when you have time visit www.easylinuxwifi.org and report your installation. All the information needed for the report is available in your computer in %s/%s/autondis-log.txt\nThank You!' % (opts.tmp_dir, card_id )
			sys.exit(1)
	
		elif choice == 'N' or choice == 'n':
			print '\nWe are sorry that the procedure failed, but don\'t get discouraged! Please visit easylinuxwifi.org for help or any other community support website. Remember, the community is here to help. You may also want to try with other .inf files if more than one was included in the dowloaded driver. You may do this by entering manual mode with -m flag. and removing all .inf files from %s/%s/ except the one you want to try to install. Also if possible report any broken urls as bugs in our bug tracker.' % (opts.tmp_dir, card_id)
			sys.exit(1)
	
		else:
			return installation_report()

##Global variables
#card_id = get_card_id()
#yourcard_dic = data[card_id]
#url = yourcard_dic['url']
#driver = yourcard_dic['driver']
#decompression = find_decompression()

#print '\n[*] Card Supported'
#try:
	#print '[*] Card detected as a %s' % (yourcard_dic['name'], )
#try:
	#print '[*] Card ciptset detected as a %s' % (yourcard_dic['chipset'], )
#try:
	#print '[*] Aditional comments were provided:\n"%s"' % (yourcard_dic['other']
#print '[*] Will attempt to fetch and install driver for the card with id: %s' % (card_id, )
#print '[*] Will attempt to fetch driver from: %s' % (url, )
#print '[*] Will attempt to install driver: %s' % (driver, )

#if (opts.ask):
	#print '   Do you want to continue?'
	#try:
		#dummy = raw_input('   Please hit <Enter> to continue, or use Ctrl+C to cancel: ')
	#except:
		#print '\n\nCanceled!\n'
		#sys.exit(1)
	#print

#print '[*] Beginning Setup Procedure:\n'

#print_driver_license()
#create_auto_ndis_folder()

#if decompression != 'manual' and not (opts.manual):
	#check_for_internet()
	#fetch()
	#extract(decompression)
	#installdriver()
	#installation_report()
#else:
	#manualmode()
	#installdriver()
	#installation_report()



def parse_args():
	'''Parse comand line options'''
	parser = OptionParser(version='version: '+__version__)
	parser.add_option('--ndiswrapper-bin', default='/usr/sbin/ndiswrapper', help='default: %default', metavar='FILE')
	parser.add_option('-t', '--tmp-dir', default='/tmp/auto-ndis', help='default: %default', metavar='DIR')
	parser.add_option('-a', '--ask', action='store_true', default=False, help='ask for confirmation')
	parser.add_option('-q', '--quiet', action='store_true', default=False, help='reduce some output')
	parser.add_option('--nocheck', action='store_true', default=False, help='doesn\'t check for ndiswrapper binary (debug only)')
	parser.add_option('-d', '--debug', action='store_true', default=False, help='turn on debugging output')
	parser.add_option('-m', '--manual', action='store_true', default=False, help='proceed with manual procedure')
	parser.add_option('-r', '--repo', default='auto', help='sets source of card information. use either remote, local or auto. defaults to %default')
	parser.add_option('-c', '--clear', action='store_true', default=False, help='clears tmp-dir before running again')
	return parser.parse_args()

def make_dirs():
	if opts.clear and os.path.isdir(opts.tmp_dir):
		for root, dirs, files in os.walk(opts.tmp_dir, topdown=False):
			for name in files:
				os.remove(os.path.join(root, name))
			for name in dirs:
				os.rmdir(os.path.join(root, name))
	if not os.path.isdir(opts.tmp_dir):
		os.mkdir(opts.tmp_dir)

def initialise_logging():
	'''Create a logging facility'''
	
	__logname__ = '%s/log' % (opts.tmp_dir,)
	logger = logging.getLogger("AUTO-NDIS CLI")
	logger.setLevel(logging.DEBUG)
	# create file handler which logs even debug messages
	fh = logging.FileHandler(__logname__)
	fh.setLevel(logging.DEBUG)
	# create console handler with a higher log level
	ch = logging.StreamHandler()
	if opts.debug:
		ch.setLevel(logging.DEBUG)
	else:
		ch.setLevel(logging.ERROR)
	# create formatter and add it to the handlers
	formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
	fh.setFormatter(formatter)
	ch.setFormatter(formatter)
	# add the handlers to the logger
	logger.addHandler(fh)
	logger.addHandler(ch)
	return logger
	
def grab_lists(pci,usb):
	pcilist = usblist = None
	
	# Try getting info from server
	if opts.repo == 'auto' or opts.repo == 'remote':
		try:
			pcilist = main.serverquery(pci)
			usblist = main.serverquery(usb)
		except ConnectionFailed:
			logger.error('Failed to connect to server')
			if opts.repo == 'auto':
				logger.error('Trying local database')
	
	# If we have nothing, either fail or try the local reposotory
	if pcilist == None and usblist == None:
		if opts.repo == 'remote':
			logger.error('Unable to establish connection. Please either check your interent connection or download the local database from FIXME...')
			sys.exit(1)
	
		database = None
		selection = None
		try:
			database = main.selectdatabase(selection)
		except DatabaseNotFound:
			logger.error('No database found for local query. Please place a database file in either the current directory, the auto-ndis file directory or in ' + opts.tmp_dir)
			sys.exit(1)
		if type(database) == type([]):
			print 'Found these databases:'
			for i,file in enumerate(database):
				print '   [%s]  %s' % (i+1,file)
			while True:
				try:
					selection = input('Please enter the number of the database to use\n')
				except Exception:
					selection = None
				if type(selection) == type(1) and selection <= len(database):
					database = database[(selection-1)]
					break
		
		pcilist = main.localquery(pci,database)
		usblist = main.localquery(usb,database)
		
	print pcilist
	print usblist
	return pcilist,usblist	

if __name__ == '__main__':
	print 'Welcome to auto-ndiswrapper %s' % (__version__, )
	print 'Please remember to always try to use the latest version of ndiswrapper with this script'
	#parse options
	opts, args = parse_args()
	#create directories
	make_dirs()
	#set up logging
	logger = initialise_logging()
	#initialise main modules
	main = AUTO_NDIS()
	#print the debug options enabled
	logger.debug('options: %s' % (opts,))
	logger.debug('arguments: %s' % (args,))
	#check for root and binary
	try:
		main.perform_initial_checks()
	except UIDError:
		logger.error('you must be root to run this script')
		logger.error('try, "su then python auto-ndis.py" or "sudo python auto-ndis.py"')
		logger.error('Error occured, exiting')
		sys.exit(1)
	except BinaryNotFound:
		logger.error('ndiswrapper not found!!!')
		logger.error('please look for "ndiswrapper" in your distribution\'s package manager and install it or go to www.ndiswrapper.com and download the latest sources')
		logger.error('Error occured, exiting')
		sys.exit(1)
	
	pci, usb = main.get_card_id()
	
	pcilist,usblist=grab_lists(pci,usb)
	
		
	print 'DONE'
	sys.exit(0)