Exemplo n.º 1
1
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)
Exemplo n.º 2
0
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
Exemplo n.º 3
0
 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)}")
Exemplo n.º 4
0
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 )
Exemplo n.º 5
0
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)
Exemplo n.º 7
0
    def __init__(self, args):
        feedbackHandler.setup()

        self.cardmonitor = CardMonitor()
        self.cardobserver = cardWebconnector(args)

        self.addCardObserver(self.cardobserver)
Exemplo n.º 8
0
 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())
Exemplo n.º 9
0
 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)
Exemplo n.º 10
0
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)
Exemplo n.º 11
0
    def __init__(self):
        self.card = None
        self.card_value = None
        self.card_type = None

        cardmonitor = CardMonitor()
        cardmonitor.addObserver(self)
Exemplo n.º 12
0
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
Exemplo n.º 13
0
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
Exemplo n.º 14
0
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)
Exemplo n.º 15
0
    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
Exemplo n.º 16
0
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)
Exemplo n.º 17
0
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()
Exemplo n.º 18
0
    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()
Exemplo n.º 19
0
 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)
Exemplo n.º 20
0
    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)
Exemplo n.º 21
0
 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)
Exemplo n.º 22
0
    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)
Exemplo n.º 23
0
 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)
Exemplo n.º 25
0
    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)
Exemplo n.º 27
0
Arquivo: tapd.py Projeto: keegan/TapIn
def poll():
    """poll for card
    """
    cardmonitor = CardMonitor()
    cardobserver = TapObserver()
    cardmonitor.addObserver(cardobserver)

    def delete():
        print('Stopping')
        cardmonitor.deleteObserver(cardobserver)

    return delete
Exemplo n.º 28
0
    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)
Exemplo n.º 29
0
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)
Exemplo n.º 30
0
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)
Exemplo n.º 32
0
    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)
Exemplo n.º 33
0
Arquivo: loop.py Projeto: Zengwn/pssi
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)
Exemplo n.º 34
0
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)
Exemplo n.º 35
0
 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)
Exemplo n.º 36
0
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
Exemplo n.º 37
0
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)
Exemplo n.º 38
0
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)
Exemplo n.º 39
0
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)
Exemplo n.º 40
0
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()
Exemplo n.º 41
0
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()
Exemplo n.º 42
0
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)
Exemplo n.º 43
0
 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)
Exemplo n.º 44
0
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 __init__(self, args):
        feedbackHandler.setup()

        self.cardmonitor = CardMonitor()
        self.cardobserver = cardWebconnector(args)

        self.addCardObserver(self.cardobserver)
Exemplo n.º 46
0
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)
Exemplo n.º 47
0
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)
Exemplo n.º 48
0
 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)
Exemplo n.º 49
0
    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)
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()
Exemplo n.º 52
0
 def __init__(self, obsindex, testcase):
     threading.Thread.__init__(self)
     self.obsindex = obsindex
     self.testcase = testcase
     self.cardmonitor = CardMonitor()
     self.observer = None
Exemplo n.º 53
0
            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:
Exemplo n.º 54
0
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)
Exemplo n.º 55
0
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)
Exemplo n.º 56
0
 def __init__(self, num_reader=0):
     self._reader = readers()[num_reader]
     self._readername = self._reader.name
     cm = CardMonitor()
     cm.addObserver(self)
     self.card = None
Exemplo n.º 57
0
#!/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"
Exemplo n.º 58
0
 def __init__(self):
     cardmonitor = CardMonitor()
     self.cardobserver = Observer()
     cardmonitor.addObserver(self.cardobserver)