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)
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)
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 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 _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 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)
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 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)