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 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
def __init__(self, client): # request any card type self.client = client self.parser = client.parser self.cardtype = AnyCardType() try: # request card insertion self.cardrequest = CardRequest(timeout=10, cardType=self.cardtype) self.cardservice = self.cardrequest.waitforcard() # attach the console tracer self.observer = LogCardConnectionObserver( ) #ConsoleCardConnectionObserver() self.cardservice.connection.addObserver(self.observer) # attach the card removal observer self.cardmonitor = CardMonitor() self.cardobserver = RemovalObserver(self) self.cardmonitor.addObserver(self.cardobserver) # connect to the card and perform a few transmits self.cardservice.connection.connect() # cache PIN self.pin_nbr = None self.pin = None except CardRequestTimeoutException: _logger.exception('time-out: no card inserted during last 10s') except Exception as exc: _logger.exception("Error during connection: {str(exc)}")
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 )
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 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 __init__(self, args): feedbackHandler.setup() self.cardmonitor = CardMonitor() self.cardobserver = cardWebconnector(args) self.addCardObserver(self.cardobserver)
def __init__(self, client): # request any card type #self.print_error("** client", client, " ** handler", client.handler) self.client = client self.parser = client.parser self.cardtype = AnyCardType() self.needs_2FA = None try: # request card insertion self.cardrequest = CardRequest(timeout=10, cardType=self.cardtype) self.cardservice = self.cardrequest.waitforcard() # attach the console tracer self.observer = LogCardConnectionObserver( ) #ConsoleCardConnectionObserver() self.cardservice.connection.addObserver(self.observer) # attach the card removal observer self.cardmonitor = CardMonitor() self.cardobserver = RemovalObserver(self) self.cardmonitor.addObserver(self.cardobserver) # connect to the card and perform a few transmits self.cardservice.connection.connect() # cache PIN self.pin_nbr = None self.pin = None except CardRequestTimeoutException: self.print_error('time-out: no card inserted during last 10s') except Exception as exc: self.print_error("Error during connection:", repr(exc), traceback.format_exc())
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)
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 __init__(self): self.card = None self.card_value = None self.card_type = None cardmonitor = CardMonitor() cardmonitor.addObserver(self)
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 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 __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
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 __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 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)
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 cardMonitor(self, smart_card_insert_cb, smart_card_remove_cb): self.smart_card_insert_cb = smart_card_insert_cb self.smart_card_remove_cb = smart_card_remove_cb if THAI_ID_CARD_DEBUG: print("ThaiIDCard: Add SmartCard observer") self.smart_card_monitor = CardMonitor() self.smart_card_observer = SmartCardObserver( card_insert_callback=self.smart_card_insert_cb, card_remove_callback=self.smart_card_remove_cb) self.smart_card_monitor.addObserver(self.smart_card_observer)
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 run(self): logger.info("Iniciando monitor") self.readermonitor = ReaderMonitor() self.cardmonitor = CardMonitor() self.cardobserver = DfvaCardObserver(eventmanager=self) self.readerobserver = DFVAReaderObserver(eventmanager=self) self.cardmonitor.addObserver(self.cardobserver) self.readermonitor.addObserver(self.readerobserver) self.run_mutex.lock() self.run_mutex.lock()
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 __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
def daemon_body(): # The main loop try: cardmonitor = CardMonitor() cardobserver = printobserver() cardmonitor.addObserver(cardobserver) while True: sleep(1000000) # sleep forever except: cardmonitor.deleteObserver(cardobserver)
def poll(): """poll for card """ cardmonitor = CardMonitor() cardobserver = TapObserver() cardmonitor.addObserver(cardobserver) def delete(): print('Stopping') cardmonitor.deleteObserver(cardobserver) return delete
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)
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)
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)
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 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
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 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 _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 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 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 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()
def __init__(self, obsindex, testcase): threading.Thread.__init__(self) self.obsindex = obsindex self.testcase = testcase self.cardmonitor = CardMonitor() self.observer = None
card.connection.connect() card.connection.addObserver(self.observer) 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:
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)
class PrintObserver(CardObserver): """A simple card observer that is notified when cards are inserted/removed from the system and prints the list of cards """ def update(self, observable, actions): (addedcards, removedcards) = actions for card in addedcards: print("+Inserted: ", toHexString(card.atr)) for card in removedcards: print("-Removed: ", toHexString(card.atr)) if __name__ == '__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) sleep(10) # 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)
def __init__(self, num_reader=0): self._reader = readers()[num_reader] self._readername = self._reader.name cm = CardMonitor() cm.addObserver(self) self.card = None
#!/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"
def __init__(self): cardmonitor = CardMonitor() self.cardobserver = Observer() cardmonitor.addObserver(self.cardobserver)