class CardManager( CardObserver ):
"""A simple card observer that is notified
when cards are inserted/removed from the system and
prints the list of cards
"""
def __init__(self):
self.cardmonitor = CardMonitor()
self.enable = False
self.cardList = []
self.cardmonitor.addObserver( self )
self.autocon = False
def update( self, observable, (addedcards, removedcards) ):
r = ""
ac = ""
if addedcards != None and len(addedcards) > 0:
r += "Added cards" + str(addedcards)
for c in addedcards:
self.cardList.append(c)
ac = self.autoConnect()
if removedcards != None and len(removedcards) > 0:
if len(r) > 0:
r += "\n"
r += "Removed cards" + str(removedcards)
for c in removedcards:
self.cardList.remove(c)
if hasattr(c,'connection'):
disconnectReaderFromCardFun(Executer.envi)
Executer.printAsynchronousOnShell("WARNING : the card has been removed, the connection is broken")
if self.enable and len(r) > 0:
if len(ac) > 0:
r += ac + "\n"
Executer.printAsynchronousOnShell(r)
else:
if len(ac) > 0:
Executer.printAsynchronousOnShell(ac)
def __init__(self):
self.card = None
self.card_value = None
self.card_type = None
cardmonitor = CardMonitor()
cardmonitor.addObserver(self)
def main():
try:
# initial screen
LOGGER_MAIN.info("System ready....")
global GPIO_CONTROL_MAIN
GPIO_CONTROL_MAIN = GPIOControl()
# card monitor
cardmonitor = CardMonitor()
cardobserver = BrizziCardObserver()
cardmonitor.addObserver(cardobserver)
# eternal loop
try:
while True:
time.sleep(1)
except Exception as err:
pass
# delete observer
cardmonitor.deleteObserver(cardobserver)
import sys
if 'win32' == sys.platform:
print('press Enter to continue')
sys.stdin.read(1)
except Exception as err:
pass
GPIO_CONTROL_MAIN.gpio_cleanup()
class APDUShell(cmd.Cmd):
"""Command shell to communicate with smartcard via APDU.
Reader selection will be performed on shell start.
Prompt will contain a selected reader's name and FID of latest selected EF or DF.
Response data and SW for each APDU will be printed in console.
"""
def __init__(self, *args, **kwargs):
# base classes are old style classes so super() not allowed here
cmd.Cmd.__init__(self, *args, **kwargs)
self.reader = select_reader()
self.card = None
self.connection = None
self.sel_obj = ''
self.card_monitor = CardMonitor()
self.card_monitor.addObserver(self)
def _card_observer_update(self, observable, (addedcards, removedcards)):
"""CardObserver interface implementation"""
if self.card and self.card in removedcards:
self.sel_obj = ''
self.card = None
self.connection = None
for card in addedcards:
if card.reader == self.reader:
self.card = card
self._set_up_connection()
break
class NfcReader(threading.Thread):
def _disable_buz(self):
hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
assert hresult == SCARD_S_SUCCESS
hresult, readers = SCardListReaders(hcontext, [])
assert len(readers) > 0
reader = readers[READER]
hresult, hcard, dwActiveProtocol = SCardConnect(
hcontext, reader, SCARD_SHARE_DIRECT,
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1)
print('Connected with active protocol', dwActiveProtocol)
hresult, response = SCardControl(hcard, SCARD_CTL_CODE(1),
[0xFF, 0x00, 0x52, 0x00, 0x00])
if hresult != SCARD_S_SUCCESS:
print('Failed to disable sound output : ' +
SCardGetErrorMessage(hresult))
def __init__(self, callback):
threading.Thread.__init__(self)
#self._disable_buz()
self.cardmonitor = CardMonitor()
self.cardobserver = NfcReaderObserver(callback)
self.cardmonitor.addObserver(self.cardobserver)
self.run_event = threading.Event()
self.run_event.set()
def run(self):
while self.run_event.is_set():
sleep(1)
def close(self):
self.run_event.clear()
self.cardmonitor.deleteObserver(self.cardobserver)
def setStudentPresent(self):
self.start()
# Creation client com avec Serveur NFC
print('thread start')
client = Client(config.URI)
try:
lastID = ""
while self.run:
cardmonitor = CardMonitor()
cardobserver = ComUsb()
cardmonitor.addObserver(cardobserver)
time.sleep(1)
tmp = cardobserver.repUid
print(tmp)
if tmp != "" and tmp != lastID:
lastID = tmp
data = client.get('/1.0/user/byTag/' + tmp)
self.cours[self.idCour].setPresent(self.reseau,
data["login"],
"present")
self.gui.setStatus(data["login"], "present")
cardmonitor.deleteObserver(cardobserver)
except Exception as e:
print(str(e))
self.finished.emit()
class smartcardBridge():
cardmonitor = None
cardobserver = None
"""
MainClass for the smartcardBride
"""
def __init__(self, args):
# feedbackHandler.setup()
self.cardmonitor = CardMonitor()
self.cardobserver = cardReader(args)
self.addCardObserver(self.cardobserver)
def shutdown(self):
print "Shutdown"
self.removeCardObserver(self.cardobserver)
# feedbackHandler.shutdown()
def addCardObserver(self, observer):
self.cardmonitor.addObserver(observer)
def removeCardObserver(self, observer):
self.cardmonitor.deleteObserver(observer)
def main():
print "Insert or remove a smartcard in the system."
print "This program will exit in 10 seconds"
print ""
cardmonitor = CardMonitor()
cardobserver = printobserver()
cardmonitor.addObserver( cardobserver )
def triggered_decorator(func):
# print("Starting observation of reader %s" % func.__defaults__[0])
class SimpleObserver(CardObserver):
reader = func.__defaults__[0]
def update(self, observable, actions):
added_cards, removed_cards = actions
# all readers involved in actions
action_readers = [c.reader for c in added_cards] + [c.reader for c in removed_cards]
# if the one we observe is not the list, we return None
if not self.reader in action_readers:
return None
# card added
if len(added_cards):
for c in added_cards:
if c.reader == self.reader:
return func(action="inserted", card=c, reader=self.reader)
# card removed
if len(removed_cards):
for c in removed_cards:
if c.reader == self.reader:
return func(action="removed", card=c, reader=self.reader)
return None
# installing observer
cm = CardMonitor()
so = SimpleObserver()
cm.addObserver(so)
return so.update
class SmartCardMonitor(CardObserver):
def __init__ (self, dispatcher):
self.cards = 0
self.dispatcher = dispatcher
self.dispatcher.update_inserted(self.get_status(), initial=True)
def get_status(self):
cards = 0
for reader in readers():
try:
connection = reader.createConnection()
connection.connect()
cards = cards + 1
except NoCardException: pass
self.cards = cards
return (self.cards > 0)
def monitor (self):
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self)
def shutdown (self):
self.cardmonitor.deleteObserver(self)
def update (self, observable, (addedcards, removedcards)):
#update the number of cards currently inserted in the system
self.cards = self.cards + len(addedcards) - len(removedcards)
if self.cards > 0:
self.dispatcher.update_inserted(True)
else:
self.dispatcher.update_inserted(False)
class APDUShell(cmd.Cmd):
"""Command shell to communicate with smartcard via APDU.
Reader selection will be performed on shell start.
Prompt will contain a selected reader's name and FID of latest selected EF or DF.
Response data and SW for each APDU will be printed in console.
"""
def __init__(self, *args, **kwargs):
# base classes are old style classes so super() not allowed here
cmd.Cmd.__init__(self, *args, **kwargs)
self.reader = select_reader()
self.card = None
self.connection = None
self.sel_obj = ''
self.card_monitor = CardMonitor()
self.card_monitor.addObserver(self)
def _card_observer_update(self, observable, (addedcards, removedcards)):
"""CardObserver interface implementation"""
if self.card and self.card in removedcards:
self.sel_obj = ''
self.card = None
self.connection = None
for card in addedcards:
if card.reader == self.reader:
self.card = card
self._set_up_connection()
break
def main():
global logger
global consumer
setup_logging()
logger = logging.getLogger(__name__)
logger.info(
"Insert MIFARE Desfire card to any reader to get its applications.")
available_reader = readers()
logger.info("Available readers: %s", available_reader)
if not available_reader:
sys.exit("No smartcard readers detected")
consumer = ConsumerThread()
consumer.start()
cardmonitor = CardMonitor()
cardobserver = MyObserver()
cardmonitor.addObserver(cardobserver)
try:
while True:
time.sleep(1)
finally:
consumer.alive = False
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(cardobserver)
class CardManager(CardObserver):
"""A simple card observer that is notified
when cards are inserted/removed from the system and
prints the list of cards
"""
def __init__(self, card_list_env, auto_connect_env):
self.cardmonitor = CardMonitor()
self.card_list_env = card_list_env
self.auto_connect_env = auto_connect_env # TODO
# self.enable = True
# self.card_list = []
self.cardmonitor.addObserver(self)
# self.autocon = False
def update(self, observable, xxx_todo_changeme):
# FIXME should raise an event and no more (WAIT FOR EVENT MANAGER)
# the business should not occured here (because of lock, etc..)
(addedcards, removedcards) = xxx_todo_changeme
r = "" # card connected or removed
# ac = "" #autoconnect result
if addedcards is not None and len(addedcards) > 0:
r += "Added card(s) " + str(addedcards)
# TODO should be in critical section
card_list = self.card_list_env.getValue()[:]
for c in addedcards:
card_list.append(c)
self.card_list_env.setValue(card_list)
# XXX
# ac = self.autoConnect()
if removedcards is not None and len(removedcards) > 0:
if len(r) > 0:
r += "\n"
r += "Removed cards" + str(removedcards)
# TODO should be in critical section
card_list = self.card_list_env.getValue()[:]
for c in removedcards:
card_list.remove(c)
self.card_list_env.setValue(card_list)
# XXX
# if hasattr(c,'connection'):
# disconnectReaderFromCardFun(Executer.envi)
# print("WARNING : the card has been removed, the connection "
# "is broken")
if len(r) > 0:
notice(r)
def run():
cardmonitor = CardMonitor()
cardobserver = PhoneObserver()
cardmonitor.addObserver(cardobserver)
sleep(10)
cardmonitor.deleteObserver(cardobserver)
class CardManager(CardObserver):
"""A simple card observer that is notified
when cards are inserted/removed from the system and
prints the list of cards
"""
def __init__(self, card_list_env, auto_connect_env):
self.cardmonitor = CardMonitor()
self.card_list_env = card_list_env
self.auto_connect_env = auto_connect_env # TODO
# self.enable = True
# self.card_list = []
self.cardmonitor.addObserver(self)
# self.autocon = False
def update(self, observable, xxx_todo_changeme):
# FIXME should raise an event and no more (WAIT FOR EVENT MANAGER)
# the business should not occured here (because of lock, etc..)
(addedcards, removedcards) = xxx_todo_changeme
r = "" # card connected or removed
# ac = "" #autoconnect result
if addedcards is not None and len(addedcards) > 0:
r += "Added card(s) " + str(addedcards)
# TODO should be in critical section
card_list = self.card_list_env.getValue()[:]
for c in addedcards:
card_list.append(c)
self.card_list_env.setValue(card_list)
# XXX
# ac = self.autoConnect()
if removedcards is not None and len(removedcards) > 0:
if len(r) > 0:
r += "\n"
r += "Removed cards" + str(removedcards)
# TODO should be in critical section
card_list = self.card_list_env.getValue()[:]
for c in removedcards:
card_list.remove(c)
self.card_list_env.setValue(card_list)
# XXX
# if hasattr(c,'connection'):
# disconnectReaderFromCardFun(Executer.envi)
# print("WARNING : the card has been removed, the connection "
# "is broken")
if len(r) > 0:
notice(r)
def wait_for_device():
cardmonitor = CardMonitor()
cardobserver = PhoneObserver()
cardmonitor.addObserver(cardobserver)
print('Waiting for device...')
sleep(10)
cardmonitor.deleteObserver(cardobserver)
os._exit(1)
def main():
monitor = CardMonitor()
observer = TapObserver(handle_card)
monitor.addObserver(observer)
try:
while True:
time.sleep(5)
finally:
monitor.deleteObserver(observer)
class NFCManager(object):
def __init__(self, session_manager, db_manager):
self.card_monitor = CardMonitor()
card_observer = MyObserver(session_manager, db_manager)
self.card_monitor.addObserver(card_observer)
def __del__(self):
self.card_monitor.instance.deleteObservers()
GPIO.cleanup()
def main():
print('Insert or remove a smartcard in the system.')
print('')
cardmonitor = CardMonitor()
cardobserver = PrintObserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1)
cardmonitor.deleteObserver(cardobserver)
def main():
print("{} Starting NFC Monitor. Waiting for input.".format(now()))
lcd.lcd_display_string(line=1, string="Waiting to serve")
lcd.lcd_display_string(line=2, string=" (some coffee.) ")
init()
cardmonitor = CardMonitor()
cardobserver = DjangoInsertionObserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1)
def poll():
"""poll for card
"""
cardmonitor = CardMonitor()
cardobserver = TapObserver()
cardmonitor.addObserver(cardobserver)
def delete():
print('Stopping')
cardmonitor.deleteObserver(cardobserver)
return delete
def daemon_body(): # The main loop try: cardmonitor = CardMonitor() cardobserver = printobserver() cardmonitor.addObserver(cardobserver) while True: sleep(1000000) # sleep forever except: cardmonitor.deleteObserver(cardobserver)
class testthread(Thread):
def __init__(self, obsindex):
Thread.__init__(self)
self.readermonitor = CardMonitor()
self.obsindex = obsindex
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex)
self.readermonitor.addObserver(self.observer)
sleep(10)
self.readermonitor.deleteObserver(self.observer)
class ContactPoint:
"""
ContactPoint is the central class of the application.
"""
debug = False
local_config = {}
listening = False
def __init__(self):
'''
Initialises the debug mode, logger.
'''
self.env = environ['CONTACTPOINT_ENV']
if self.env == 'development':
self.debug = True
self.init_emulator()
self.logger = Logger(self.debug)
self.logger.log('System started...')
self.server = Server(self, self.debug)
self.listen()
def process(self, action, tag_id=None):
'''
The process function is called each time an action happens on the RFID
reader.
'''
response = dict(action=action)
if tag_id is not None:
response['tag_id'] = tag_id
self.logger.debug(response)
self.server.send_msg('listen_taps', response)
def init_emulator(self):
'''
If the application is running in development mode, the process method is
aliased as emulate too. This is for nomenclature convenience. This
function shall be called as emulate, to emulate card taps in development
mode.
'''
if self.debug is True:
self.emulate = self.process
def listen(self):
'''
The listen function is called during initialisation of the class & the
application. It initialises the process of starting to listen to card
taps on the reader.
'''
self.monitor = CardMonitor()
self.observer = Observer(self)
self.monitor.addObserver(self.observer)
class ContactPoint:
"""
ContactPoint is the central class of the application.
"""
debug = False
local_config = {}
listening = False
def __init__(self):
'''
Initialises the debug mode, logger.
'''
self.env = environ['CONTACTPOINT_ENV']
if self.env == 'development':
self.debug = True
self.init_emulator()
self.logger = Logger(self.debug)
self.logger.log('System started...')
self.server = Server(self, self.debug)
self.listen()
def process(self, action, tag_id=None):
'''
The process function is called each time an action happens on the RFID
reader.
'''
response = dict(action=action)
if tag_id is not None:
response['tag_id'] = tag_id
self.logger.debug(response)
self.server.send_msg('listen_taps', response)
def init_emulator(self):
'''
If the application is running in development mode, the process method is
aliased as emulate too. This is for nomenclature convenience. This
function shall be called as emulate, to emulate card taps in development
mode.
'''
if self.debug is True:
self.emulate = self.process
def listen(self):
'''
The listen function is called during initialisation of the class & the
application. It initialises the process of starting to listen to card
taps on the reader.
'''
self.monitor = CardMonitor()
self.observer = Observer(self)
self.monitor.addObserver(self.observer)
class testthread(threading.Thread):
def __init__(self, obsindex, testcase):
threading.Thread.__init__(self)
self.obsindex = obsindex
self.testcase = testcase
self.cardmonitor = CardMonitor()
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex, self.testcase)
self.cardmonitor.addObserver(self.observer)
time.sleep(1)
self.cardmonitor.deleteObserver(self.observer)
def main():
# set event handlers
Event.on('insert', cardInsert)
Event.on('remove', cardRemove)
print('Scanning for cards')
cardmonitor = CardMonitor()
cardobserver = Observer()
cardmonitor.addObserver(cardobserver)
# remove the cardmonitor afterwards
# cardmonitor.deleteObserver(cardobserver)
while True:
continue
def startLoop():
now = datetime.datetime.today()
directory = "%04u-%02u-%02u_%02uh%02um%02us" % (now.year, now.month, now.day, now.hour, now.minute, now.second)
os.makedirs(directory)
cardmonitor = CardMonitor()
cardobserver = observer(directory)
cardmonitor.addObserver(cardobserver)
while True:
try:
time.sleep(60)
except:
break
cardmonitor.deleteObserver(cardobserver)
def daemon_body():
# The main loop
logging.info("INFO waiting for card... (hit CTRL+C to stop)")
try:
cardmonitor = CardMonitor()
cardobserver = printobserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1000000) # sleep forever
except:
cardmonitor.deleteObserver(cardobserver)
class testthread(Thread):
def __init__(self, obsindex):
Thread.__init__(self)
self.readermonitor = CardMonitor()
self.obsindex = obsindex
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex)
self.readermonitor.addObserver(self.observer)
sleep(10)
self.readermonitor.deleteObserver(self.observer)
class _CcidCardObserver(CardObserver):
def __init__(self, controller):
self._controller = weakref.ref(controller)
self._monitor = CardMonitor()
self._monitor.addObserver(self)
def update(self, observable, tup):
(added, removed) = tup
c = self._controller()
if c:
c._update([card.reader for card in added],
[r.reader for r in removed])
def delete(self):
self._monitor.deleteObservers()
def startLoop():
now = datetime.datetime.today()
directory = "%04u-%02u-%02u_%02uh%02um%02us" % \
(now.year, now.month, now.day, now.hour, now.minute, now.second)
os.makedirs(directory)
cardmonitor = CardMonitor()
cardobserver = observer(directory)
cardmonitor.addObserver(cardobserver)
while True:
try:
time.sleep(60)
except:
break
cardmonitor.deleteObserver(cardobserver)
class testthread(threading.Thread):
def __init__(self, obsindex, testcase):
threading.Thread.__init__(self)
self.obsindex = obsindex
self.testcase = testcase
self.cardmonitor = CardMonitor()
self.observer = None
def run(self):
# create and register observer
self.observer = printobserver(self.obsindex, self.testcase)
self.cardmonitor.addObserver(self.observer)
time.sleep(1)
self.cardmonitor.deleteObserver(self.observer)
class ACR122():
def __init__(self, obs_impl=uid.ReadUidObserver):
# Declaration
self.__monitor = None
self.__observer = None
# Initialization
self.__monitor = CardMonitor()
self.__observer = obs_impl() # XXX: Extend to mutiple observer
def attachObserver(self):
self.__monitor.addObserver(self.__observer)
def detachObserver(self):
self.__monitor.deleteObserver(self.__observer)
def display_atr(self, reader="usb", verbose=False):
print_info("Scanning present readers...")
cardmonitor = CardMonitor()
selectobserver = ATRObserver(verbose)
cardmonitor.addObserver(selectobserver)
while True:
try:
sleep(0.1)
except KeyboardInterrupt:
print()
print_error("Module Interrupted")
cardmonitor.deleteObserver(selectobserver)
return True
def main():
if 'linux' in sys.platform and os.getegid() != 0:
sys.exit("You must to run this sctipt as root.")
available_reader = readers()
if not available_reader:
sys.exit("No card readers detected")
card_monitor = CardMonitor()
card_observer = KUSTDCardObserver()
card_monitor.addObserver(card_observer)
while True:
time.sleep(0.2)
class LecteurCarteTest(unittest.TestCase):
def setUp(self):
self.q = Queue()
self.cardmonitor = CardMonitor()
self.lecteur = Lecteur(self.q)
self.cardmonitor.addObserver(self.lecteur)
def test_lecturecarte(self):
print(
'\nVous avez 10 secondes pour présenter une ou plusieurs cartes au lecteur.'
)
time.sleep(10)
self.assertNotEqual(self.q.qsize(), 0,
'Le lecteur n\'a lu aucune carte.')
self.cardmonitor.deleteObserver(self.lecteur)
class _CcidCardObserver(CardObserver):
def __init__(self, controller):
self._controller = weakref.ref(controller)
self._monitor = CardMonitor()
self._monitor.addObserver(self)
def update(self, observable, tup):
(added, removed) = tup
c = self._controller()
if c:
c._update([card.reader for card in added],
[r.reader for r in removed])
def delete(self):
self._monitor.deleteObservers()
def entry_point():
print u"Smartcard monitor applet by Lauri Võsandi <*****@*****.**>"
if not os.path.exists(PCSCD):
print "Unable to find", PCSCD, "are you sure it is installed"
applet = SmartcardApplet()
reader_monitor = ReaderMonitor()
reader_monitor.addObserver(applet.reader_observer)
card_monitor = CardMonitor()
card_monitor.addObserver(applet.card_observer)
try:
gtk.main()
except KeyboardInterrupt:
pass
card_monitor.deleteObserver(applet.card_observer)
reader_monitor.deleteObserver(applet.reader_observer)
class CardManager(CardObserver):
"""A simple card observer that is notified
when cards are inserted/removed from the system and
prints the list of cards
"""
def __init__(self):
self.cardmonitor = CardMonitor()
self.enable = False
self.cardList = []
self.cardmonitor.addObserver(self)
self.autocon = False
def update(self, observable, (addedcards, removedcards)):
r = ""
ac = ""
if addedcards != None and len(addedcards) > 0:
r += "Added cards" + str(addedcards)
for c in addedcards:
self.cardList.append(c)
ac = self.autoConnect()
if removedcards != None and len(removedcards) > 0:
if len(r) > 0:
r += "\n"
r += "Removed cards" + str(removedcards)
for c in removedcards:
self.cardList.remove(c)
if hasattr(c, 'connection'):
disconnectReaderFromCardFun(Executer.envi)
Executer.printAsynchronousOnShell(
"WARNING : the card has been removed, the connection is broken"
)
if self.enable and len(r) > 0:
if len(ac) > 0:
r += ac + "\n"
Executer.printAsynchronousOnShell(r)
else:
if len(ac) > 0:
Executer.printAsynchronousOnShell(ac)
class CardWatcher:
def __init__(self, on_card):
self.monitor = CardMonitor()
self.observer = MyObserver(on_card)
def start(self):
available_reader = readers()
if not available_reader:
raise Exception('No smartcard readers detected')
self.monitor.addObserver(self.observer)
while True:
time.sleep(1)
self.monitor.deleteObserver(self.observer)
class NfcReader():
def __init__(self, o2m=None):
print("NFCReader initializing...")
print("Insert or remove a smartcard in the system.")
print("")
self.log = logging.getLogger(__name__)
self.o2m = o2m
self.cardmonitor = CardMonitor()
self.cardobserver = PrintObserver()
self.cardmonitor.addObserver(self.cardobserver)
self.cardobserver.events.on_change += self.update_change
'''
Callback function called when the card observer triggers the event on_change.
this function just pass the parameters to the parent NfcToMopidy object
'''
def update_change(self, addedCards, removedCards, activeCards):
self.o2m.get_new_cards(addedCards, removedCards, activeCards)
'''
Start an infinite loop to keep the readers polling
'''
def loop(self):
try:
while True:
sleep(10)
except KeyboardInterrupt:
self.remove_observer()
self.log.info('Keyboard Interrupt : Removing observer')
'''
If killed properly we remove the observer to prevent forever polling on the readers
'''
def remove_observer(self):
# don't forget to remove observer, or the
# monitor will poll forever...
self.cardmonitor.deleteObserver(self.cardobserver)
self.log.info('Observer removed : Connection closed')
def TapN():
print("Insert or remove a smartcard in the system.")
print("This program will exit in 10 seconds")
print("")
cardmonitor = CardMonitor()
cardobserver = PrintObserver()
cardmonitor.addObserver(cardobserver)
sleep(1)
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(cardobserver)
import sys
if 'win32' == sys.platform:
print('press Enter to continue')
sys.stdin.read(1)
return cardobserver.Tap
class Webconnector():
cardmonitor = None
cardobserver = None
"""
MainClass for the Webconnector
"""
def __init__(self, args):
feedbackHandler.setup()
self.cardmonitor = CardMonitor()
self.cardobserver = cardWebconnector(args)
self.addCardObserver(self.cardobserver)
def shutdown(self):
print "Shutdown"
self.removeCardObserver(self.cardobserver)
feedbackHandler.shutdown()
def addCardObserver(self, observer):
self.cardmonitor.addObserver(observer)
def removeCardObserver(self, observer):
self.cardmonitor.deleteObserver(observer)
def checkConnection(self, url):
try:
# Try connection
response = urllib2.urlopen(url, timeout=1)
# Connection successful, activate Connection-LED
feedbackHandler.setFeedback(feedbackHandler.CONNECTION,
feedbackHandler.ACTIVE)
return True
except urllib2.URLError as e:
# No Connection to Server
feedbackHandler.setFeedback(feedbackHandler.CONNECTION,
feedbackHandler.INACTIVE)
finally:
return False
class Webconnector():
cardmonitor = None
cardobserver = None
"""
MainClass for the Webconnector
"""
def __init__(self, args):
feedbackHandler.setup()
self.cardmonitor = CardMonitor()
self.cardobserver = cardWebconnector(args)
self.addCardObserver(self.cardobserver)
def shutdown(self):
print "Shutdown"
self.removeCardObserver(self.cardobserver)
feedbackHandler.shutdown()
def addCardObserver(self, observer):
self.cardmonitor.addObserver(observer)
def removeCardObserver(self, observer):
self.cardmonitor.deleteObserver(observer)
def checkConnection(self, url):
try:
# Try connection
response = urllib2.urlopen(url, timeout=1)
# Connection successful, activate Connection-LED
feedbackHandler.setFeedback(feedbackHandler.CONNECTION, feedbackHandler.ACTIVE)
return True
except urllib2.URLError as e:
# No Connection to Server
feedbackHandler.setFeedback(feedbackHandler.CONNECTION, feedbackHandler.INACTIVE)
finally:
return False
class CardAndReaderTreePanel(wx.Panel):
"""Panel containing the smart card and reader tree controls."""
class _CardObserver(CardObserver):
"""Inner CardObserver. Gets notified of card insertion
removal by the CardMonitor."""
def __init__(self, cardtreectrl):
self.cardtreectrl = cardtreectrl
def update(self, observable, handlers):
"""CardObserver callback that is notified
when cards are added or removed."""
addedcards, removedcards = handlers
self.cardtreectrl.OnRemoveCards(removedcards)
self.cardtreectrl.OnAddCards(addedcards)
class _ReaderObserver(ReaderObserver):
"""Inner ReaderObserver. Gets notified of reader insertion/removal
by the ReaderMonitor."""
def __init__(self, readertreectrl):
self.readertreectrl = readertreectrl
def update(self, observable, handlers):
"""ReaderObserver callback that is notified when
readers are added or removed."""
addedcards, removedcards = handlers
self.readertreectrl.OnRemoveReaders(removedreaders)
self.readertreectrl.OnAddReaders(addedreaders)
def __init__(self, parent, appstyle, clientpanel):
"""Constructor. Create a smartcard and reader tree control on the
left-hand side of the application main frame.
@param parent: the tree panel parent
@param appstyle: a combination of the following styles (bitwise or |)
- TR_SMARTCARD: display a smartcard tree panel
- TR_READER: display a reader tree panel
- default is TR_DEFAULT = TR_SMARTCARD
@param clientpanel: the client panel to notify of smartcard and reader events
"""
wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
sizer = wx.BoxSizer(wx.VERTICAL)
# create the smartcard tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_SMARTCARD:
self.cardtreectrl = CardTreeCtrl(self, clientpanel=clientpanel)
# create the smartcard insertion observer
self.cardtreecardobserver = self._CardObserver(self.cardtreectrl)
# register as a CardObserver; we will ge
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.cardtreecardobserver)
sizer.Add(
self.cardtreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
# create the reader tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_READER:
self.readertreectrl = ReaderTreeCtrl(
self, clientpanel=clientpanel)
# create the reader insertion observer
self.readertreereaderobserver = self._ReaderObserver(
self.readertreectrl)
# register as a ReaderObserver; we will ge
# notified of added/removed readers
self.readermonitor = ReaderMonitor()
self.readermonitor.addObserver(self.readertreereaderobserver)
# create the smartcard insertion observer
self.readertreecardobserver = self._CardObserver(
self.readertreectrl)
# register as a CardObserver; we will get
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.readertreecardobserver)
sizer.Add(
self.readertreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
self.SetSizer(sizer)
self.SetAutoLayout(True)
def OnDestroy(self, event):
"""Called on panel destruction."""
# deregister observers
if hasattr(self, 'cardmonitor'):
self.cardmonitor.deleteObserver(self.cardtreecardobserver)
if hasattr(self, 'readermonitor'):
self.readermonitor.deleteObserver(self.readertreereaderobserver)
self.cardmonitor.deleteObserver(self.readertreecardobserver)
event.Skip()
apdu = SELECT + DF_TELECOM
response, sw1, sw2 = card.connection.transmit(apdu)
if sw1 == 0x9F:
apdu = GET_RESPONSE + [sw2]
response, sw1, sw2 = card.connection.transmit(apdu)
for card in removedcards:
print "-Removed: ", toHexString(card.atr)
try:
print "Insert or remove a SIM card in the system."
print "This program will exit in 60 seconds"
print ""
cardmonitor = CardMonitor()
selectobserver = selectDFTELECOMObserver()
cardmonitor.addObserver(selectobserver)
sleep(60)
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(selectobserver)
import sys
if 'win32' == sys.platform:
print 'press Enter to continue'
sys.stdin.read(1)
except:
print exc_info()[0], ':', exc_info()[1]
def init(): # инициализация работы
cardmonitor = CardMonitor()
selectobserver = selectDFTELECOMObserver()
cardmonitor.addObserver(selectobserver)
class ireadyou(object,CardObserver,ReaderObserver):
GLADE_FILE = "gui/ireadyou/ireadyou.glade"
def __init__(self, ticket = None):
"Create and show main window."
self.main_window_xml = gtk.glade.XML(self.GLADE_FILE, "main")
self.main_window = self.main_window_xml.get_widget("main")
self.card_tabs = self.main_window_xml.get_widget("card_tabs")
while self.card_tabs.get_n_pages() > 0:
self.card_tabs.remove_page(0)
for t in self.CARD_TYPES:
a, b, l = gtk.Alignment(yscale=1,xscale=1,xalign=0.5,yalign=0.5), gtk.VBox(), gtk.Label(t[1])
a.add(b)
a.show()
b.show()
l.show()
self.card_tabs.append_page(a, tab_label=l)
self.ticket_button_group = gtk.RadioButton()
self.ticket_button_group._ticket = None
self.status_area = self.main_window_xml.get_widget("status_area")
self.known_readers = []
self.known_cards = {} # Note stupid: the keys to this dict are not objects from the known_readers list but rather reader name strings
self.connected_cards = {} # Again: the keys are not cards but repr(card)
self.tickets = {} # ditto
self.ticket_displayed = None # This is either None or a tuple (card object, ticket object)
self._update_status()
self.logbuf = FileLikeTextBuffer()
sys.stdout = self.logbuf.for_stream(sys.stdout)
sys.stderr = self.logbuf.for_stream(sys.stderr)
self.logview = self.main_window_xml.get_widget("logview")
self.logview.set_buffer(self.logbuf.buffer)
self.logbuf.add_view(self.logview)
signals = {
"on_exit_clicked": self.exit_clicked,
"on_main_delete_event": self.exit_clicked,
"on_main_destroy": gtk.main_quit,
}
self.main_window_xml.signal_autoconnect(signals)
self._clear_display()
self.rmon = ReaderMonitor()
self.cmon = CardMonitor()
self.rmon.addObserver(self)
self.cmon.addObserver(self)
def _clear_display(self):
self.card_tabs.set_current_page(0)
for i in range(self.card_tabs.get_n_pages()):
a = self.card_tabs.get_nth_page(i)
vbox = a.get_child()
for c in vbox.get_children():
vbox.remove(c)
label = self.card_tabs.get_tab_label(a)
label.set_property("sensitive", False)
def _update_status(self):
for c in self.status_area.get_children():
self.status_area.remove(c)
if len(self.known_readers) == 0:
self.status_area.add( gtk.Label(u"Keine Lesegeräte angeschlossen.") )
else:
for reader in self.known_readers:
frame = gtk.Frame(label=str(reader))
if len(self.known_cards[ reader.name ]) == 0:
frame.add( gtk.Label(u"Keine Karten verbunden.") )
else:
vbox = gtk.VBox()
for card in self.known_cards[ reader.name ]:
if self.connected_cards.has_key(repr(card)):
card_ = self.connected_cards[ repr(card) ]
cardname = card_.get_driver_name()
else:
cardname = str(card)
hbox = gtk.HBox()
cardlabel = gtk.Label( "<b>%s</b>: " % cardname )
cardlabel.set_use_markup(True)
hbox.pack_start(cardlabel, expand=False)
vbox2 = gtk.VBox()
hbox.pack_start(vbox2, expand=True)
for ticket in self.tickets[ repr(card) ]:
button = gtk.RadioButton(group=self.ticket_button_group, label=str(ticket), use_underline=False)
vbox2.pack_start(button, expand=False)
button.connect("toggled", self._ticket_button_toggled)
button._ticket = (card, ticket)
if self.ticket_displayed is not None and ticket == self.ticket_displayed[1]:
button.set_active(True)
vbox.add(hbox)
frame.add(vbox)
self.status_area.add(frame)
self.status_area.show_all()
def _format_datum(d):
return d.strftime("%x")
CARD_TYPES = [
(("SCHUL_T",),
"Schulticket", (
("Name", "name_klar", None),
("Alter", "alter", None),
("Geburtsdatum", "geburtsdatum", _format_datum),
("Schule", "schule", None),
(u"Kartengültigkeit", "gueltigkeit", None),
),
),
(("JOBT_ERW",),
"Jobticket", (
("Name", "name_klar", None),
("Geburtsdatum", "geburtsdatum", _format_datum),
(u"Kartengültigkeit", "gueltigkeit", None),
),
),
(("MT_ABO",),
"Monatsabo", (
("Abo-Nummer", "abonr", None),
(u"Kartengültigkeit", "gueltigkeit", None),
),
),
(None,
"Anderes", (
),
),
]
def _ticket_button_toggled(self, togglebutton):
self.ticket_displayed = None
for b in togglebutton.get_group():
if b.get_active():
if hasattr(b, "_ticket"):
self.ticket_displayed = b._ticket
self._update_ticket_display()
def _update_ticket_display(self):
self._clear_display()
if self.ticket_displayed is None:
return
todisplay = self.ticket_displayed[1]
for i,t in enumerate(self.CARD_TYPES):
if todisplay.tickettyp in t[0]:
break
# Note: implicit selection of the last card type when no match is found
self.card_tabs.set_current_page(i)
a = self.card_tabs.get_nth_page(i)
vbox = a.get_child()
label = self.card_tabs.get_tab_label(a)
label.set_property("sensitive", True)
for labeltext, propertyname, transformation in t[2]:
frame = gtk.Frame(label=labeltext)
content = getattr(todisplay, propertyname, None)
contenttext = str( transformation is not None and transformation(content) or content )
contentlabel = gtk.Label("<b><tt><big>%s</big></tt></b>" % contenttext)
contentlabel.set_use_markup(True)
contentlabel.show()
frame.add( contentlabel )
frame.show()
vbox.add(frame)
def exit_clicked(self, widget, event=None, data=None):
gtk.main_quit()
return True
def run(self):
gtk.main()
# From the CardObserver and ReaderObserver classes
def update( self, observable, (added, removed) ):
try:
gtk.gdk.threads_enter()
#print observable, added, removed
if observable is self.rmon.instance:
self.reader_update(observable, (added, removed) )
elif observable is self.cmon.instance:
self.card_update(observable, (added, removed) )
self._update_status()
self._update_ticket_display()
finally:
gtk.gdk.threads_leave()
print name
year, month, day =gdetails.getExpiryDate()
#print gdetails.getDOB()
#print gdetails.getNationalityCode()
#print gdetails.getGender()
#print gdetails.getPrintDate()
roll_list = get_rollnos("Roll_list.txt")
#fingerprint_read(connection)
#eadEF5(connection)
if check_roll(rollno, roll_list) and check_date(day, month, year):
create_log("Entry_log.txt", rollno, name)
GPIO.output(16,GPIO.LOW)
os.system("echo 1 | sudo tee /sys/class/leds/led0/brightness")
print "Access Granted"
time.sleep(5)
GPIO.output(16,GPIO.HIGH)
os.system("echo 0 | sudo tee /sys/class/leds/led0/brightness")
print "Access Closed"
else:
create_log("No_entry log.txt", rollno, name)
print "Access Denied"
# print "Script is active"
GPIO.setmode(GPIO.BCM)
GPIO.setup(16,GPIO.OUT)
GPIO.output(16,GPIO.HIGH)
MONITOR = CardMonitor()
OBSERVER = Card_Read()
MONITOR.addObserver(OBSERVER)
signal.pause()
def __init__(self, num_reader=0):
self._reader = readers()[num_reader]
self._readername = self._reader.name
cm = CardMonitor()
cm.addObserver(self)
self.card = None
def main():
import sys
# TODO Add input for URI to serial numbers file
if len(sys.argv) == 2:
try:
download(sys.argv[1])
except IOError:
print 'Filename not found.'
else:
# Setup GPIO
if GPIO_available:
log.info("Enabling GPIO")
initGPIO()
"""
# Start card monitor
card = CardObservingThread()
card.setDaemon(True)
card.start()
"""
# Instanciate a monitor
cardmonitor = CardMonitor()
# Create a new observerable
cardobserver = CardObserver()
try:
cardmonitor.addObserver(cardobserver)
success = True
log.info('Card Observer Added')
except:
log.warning('addObserver exception')
if (cardmonitor == None):
log.warning('cardmonitor does not exist')
if (cardobserver == None):
log.warning('cardobserver does not exist')
# if (card.is_alive()):
if (True):
log.info("Starting Background File Service")
# Start file grabbing process
backgroundFile = FetchFile()
backgroundFile.setDaemon(True)
backgroundFile.start()
# Start web server
#log.info("Starting Web Server")
#root = getSerial()
#factory = Site(root)
#reactor.listenTCP(8880, factory)
#reactor.run()
else:
log.warning("Did not start background file service")
Loop = True
while (Loop):
# i = raw_input ("q for exit\n")
#if (i == 'q'):
# log.info('Quitting')
# if (backgroundFile.isAlive()):
# backgroundFile.stop()
# Loop = False
# break # breaks out of the while loop
# New file downloaded. Parse to dict
if (backgroundFile.newFile == True):
backgroundFile.newFile = False
cs.parseFile("dlserials.txt")
if (cs.cardPresent()):
if (cs.validCards()):
log.info("Valid card found")
else:
log.info("Card Present but Not Valid")
else:
log.info("No Cards Present")
time.sleep(.5)
def __init__(self):
cardmonitor = CardMonitor()
self.cardobserver = Observer()
cardmonitor.addObserver(self.cardobserver)
#!/usr/bin/python
from smartcard.CardMonitoring import CardMonitor, CardObserver
from smartcard.util import *
# a simple card observer that prints inserted/removed cards
class printobserver( CardObserver ):
def update( self, observable, (addedcards, removedcards) ):
print "Test"
for card in addedcards:
print "+Inserted: ", toHexString( card.atr )
for card in removedcards:
print "-Removed: ", toHexString( card.atr )
print "Insert or remove a smartcard in the system."
print "This program will exit in 10 seconds"
print ""
cardmonitor = CardMonitor()
cardobserver = printobserver()
cardmonitor.addObserver( cardobserver )
print "Done"
class Command(BaseCommand):
args = ''
help = 'This program puts a default order (one coffee or tea) when a card is read.'
def _enter_state(self, state):
states = {
STATE_NONE: {
'name': 'STATE_NONE',
# no call
},
STATE_INITIAL: {
'name': 'STATE_INITIAL',
'call': self._enter_initial,
},
STATE_WAITING_FOR_READER: {
'name': 'STATE_WAITING_FOR_READER',
'call': self._enter_waiting_for_reader,
},
STATE_READING_CARDS: {
'name': 'STATE_READING_CARDS',
'call': self._enter_reading_cards,
},
STATE_EXIT: {
'name': 'STATE_EXIT',
'call': self._enter_exit,
},
}
if states.has_key(state):
state_msg = 'state change: %s -> %s' % (
states[self.state]['name'],
states[state]['name'],
)
log.info(state_msg)
else:
err_msg = 'bad state: %r' % state
log.error(err_msg)
raise StateChangeError(err_msg)
self.state = state
states[state]['call']()
def _setup_card_monitor_and_observer(self):
self.card_monitor = CardMonitor()
self.card_observer = OrderObserver()
self.card_observer.initialize()
self.card_monitor.addObserver(self.card_observer)
def _tear_down_card_monitor_and_observer(self):
if self.card_observer is not None and self.card_monitor is not None:
self.card_monitor.deleteObserver(self.card_observer)
self.card_monitor = None
self.card_observer = None
def _enter_waiting_for_reader(self):
tasks.blipper_waiting.delay()
while len(scsystem.readers()) == 0:
sleep(1)
self._enter_state(STATE_READING_CARDS)
def _enter_reading_cards(self):
self._setup_card_monitor_and_observer()
tasks.blipper_reading_cards.delay()
while len(scsystem.readers()) != 0:
sleep(1)
self._tear_down_card_monitor_and_observer()
self._enter_state(STATE_WAITING_FOR_READER)
def _enter_exit(self):
self._tear_down_card_monitor_and_observer()
log.info('finished program, normal exit')
def _enter_initial(self):
initial_readers = scsystem.readers()
log.info('connected readers: %r' % initial_readers)
tasks.blipper_ready.delay()
try:
if len(initial_readers) == 0:
initial_state = STATE_WAITING_FOR_READER
elif len(initial_readers) == 1:
initial_state = STATE_READING_CARDS
else:
err_msg = '%d readers connected' % len(initial_readers)
raise CardReaderError(err_msg)
self._enter_state(initial_state)
except KeyboardInterrupt:
log.info('user exit')
self._enter_state(STATE_EXIT)
def handle(self, *args, **options):
valid = True
if not valid:
raise CommandError('invalid config')
if settings.CARDREADER_PREFETCH:
log.info('prefetch enabled')
tasks.blipper_prefetch_users.delay()
else:
log.info('prefetch disabled')
self.card_monitor = None
self.card_observer = None
self.state = STATE_NONE
self._enter_state(STATE_INITIAL)
