private void UpdateReaderState(SCardCardReaderState state, string cardReaderName)
        {
            PcscCardReader CardReader = (PcscCardReader)this.Readers[cardReaderName];

            SCardReaderState NewState = state.dwEventState;

            if ((NewState & SCardReaderState.Unavailable) != 0 && this.scardApi.ListReaders().Contains(cardReaderName) == false)
            {
                //CardReader was removed, if state changes to unavailiable _and_ reader is not in the list anymore.
                //Otherwise, reader was opened in direct mode
                this.RemoveCardReader(CardReader);
                return;
            }
            else
            {
                try
                {
                    // CardReader state changed
                    CardReader.CardReaderState = state;
                    return;
                }
                catch (Exception Error)
                {
                    Trace.Fail($"Exception was thrown inside status change handler. This may lead to a blocking application! Origianl Exception was: {Error.Message}");
                    throw;
                }
            }
        }
        public void CardChangeEventCntSetEventStateValueTest()
        {
            var state = new SCardReaderState {
                EventStateValue = IntPtr.Zero
            };

            state.CardChangeEventCnt
            .Should()
            .Be(0);

            //set the counter (upper 2 bytes of the event state) to 1
            state.EventStateValue = unchecked (new IntPtr(0x00010000));
            state.CardChangeEventCnt
            .Should()
            .Be(1);

            //Set the maximum value
            //The maximum value depends on the architecture.
            //If the process is running 32-bit, IntPtr(long) throws an exception.
            if (IntPtr.Size == sizeof(Int64))
            {
                state.EventStateValue = unchecked (new IntPtr(0xFFFF0000));
                state.CardChangeEventCnt
                .Should()
                .Be(0xFFFF);
            }
            else
            {
                state.EventStateValue = unchecked (new IntPtr(0x7FFF0000));
                state.CardChangeEventCnt
                .Should()
                .Be(0x7FFF);
            }
        }
        private void RefreshData()
        {
            card = context.GetReaderStatus(reader);
            string atr = BitConverter.ToString(card.Atr ?? new byte[0]);

            if (atr == "")
            {
                statusLabel.ForeColor = Color.Orange;
                statusLabel.Text      = "ОЖИДАНИЕ КАРТЫ";
                atrTxtBox.Text        = "ВСТАВЬТЕ КАРТУ";
            }
            else
            {
                if (atrs.Contains(atr))
                {
                    statusLabel.ForeColor = Color.Green;
                    statusLabel.Text      = "АВТОРИЗОВАНО";
                }
                else
                {
                    statusLabel.ForeColor = Color.FromArgb(220, 10, 10);
                    statusLabel.Text      = "НЕ АВТОРИЗОВАНО";
                }
                atrTxtBox.Text = atr;
            }
        }
            private void ResetCardReaderStates()
            {
                this.pnpNotificationDeviceState = SCardReaderState.Unaware;
                foreach (CardReaderBase CardReader in this.owner.Readers.ToArray())
                {
                    this.owner.RemoveCardReader(CardReader);
                }

                this.InitialSetupCardReaders();
            }
Exemple #5
0
        string Readcardid()
        {
            SCardContext card = new SCardContext();

            card.Establish(SCardScope.System);
            string[]         readers = card.GetReaders();
            SCardReaderState status  = card.GetReaderStatus(readers[0]);

            return(BitConverter.ToString(status.Atr ?? new byte[0]));
        }
 private void HandleCardReaderStateChange(string cardReaderName, SCardCardReaderState state)
 {
     if (cardReaderName == PollThread.PnpNotificationDeviceName)
     {
         this.pnpNotificationDeviceState = state.dwEventState;
         this.owner.InsertNewCardReaders();
     }
     else
     {
         this.owner.UpdateReaderState(state, cardReaderName);
         return;
     }
 }
        public void RefreshCardData()
        {
            SCardContext card = new SCardContext();

            card.Establish(SCardScope.System);
            string[]         readers = card.GetReaders();
            SCardReaderState status  = card.GetReaderStatus(readers[0]);

            CardDataBox.Text += status.UserData + " - User Data\n" + Environment.NewLine;
            CardDataBox.Text += status.ReaderName + " - Reader\n" + Environment.NewLine;
            CardDataBox.Text += status.CurrentStateValue + " - Curent State Value\n" + Environment.NewLine;
            CardDataBox.Text += BitConverter.ToString(status.Atr ?? new byte[0]) + " - Answer to Reset\n" + Environment.NewLine;
        }
Exemple #8
0
        private static void PrintReaderState(SCardReaderState state)
        {
            Console.WriteLine(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
            var atr = BitConverter.ToString(state.Atr ?? new byte[0]);

            Console.WriteLine($"Reader: {state.ReaderName}\n" +
                              $"CurrentState: {state.CurrentState}\n" +
                              $"EventState: {state.EventState}\n" +
                              $"CurrentStateValue: {state.CurrentStateValue}\n" +
                              $"EventStateValue: {state.EventStateValue}\n" +
                              $"UserData: {state.UserData}\n" +
                              $"CardChangeEventCnt: {state.CardChangeEventCnt}\n" +
                              $"ATR: {atr}");
        }
        public void CardChangeEventCntSetTest()
        {
            var state = new SCardReaderState {
                EventState         = SCRState.Empty,
                CardChangeEventCnt = 0
            };

            state.CardChangeEventCnt
            .Should()
            .Be(0);

            ((uint)state.EventStateValue.ToInt32())
            .Should()
            .Be((uint)SCRState.Empty);

            state.EventState
            .Should()
            .Be(SCRState.Empty, "EventState should not change by setting the Counter");

            //set the counter to 1
            state.CardChangeEventCnt = 1;
            state.CardChangeEventCnt
            .Should()
            .Be(1);
            ((uint)state.EventStateValue.ToInt32())
            .Should()
            .Be(0x00010010);

            state.EventState
            .Should()
            .Be(SCRState.Empty, "EventState should not change by setting the Counter");

            //Set the maximum value
            state.CardChangeEventCnt = 65535;
            state.CardChangeEventCnt
            .Should()
            .Be(65535);
            ((uint)state.EventStateValue.ToInt32())
            .Should().Be(0xFFFF0010);

            //try to set a value that is too high
            ((Action)(() => state.CardChangeEventCnt = 65536))
            .ShouldThrow <ArgumentException>();

            //try to set a negative value
            ((Action)(() => state.CardChangeEventCnt = -1))
            .ShouldThrow <ArgumentException>();
        }
        public void CardChangeEventCntSetTest() {
            var state = new SCardReaderState {
                EventState = SCRState.Empty,
                CardChangeEventCnt = 0
            };
            state.CardChangeEventCnt
                .Should()
                .Be(0);

            ((uint) state.EventStateValue.ToInt32())
                .Should()
                .Be((uint) SCRState.Empty);

            state.EventState
                .Should()
                .Be(SCRState.Empty, "EventState should not change by setting the Counter");

            //set the counter to 1
            state.CardChangeEventCnt = 1;
            state.CardChangeEventCnt
                .Should()
                .Be(1);
            ((uint) state.EventStateValue.ToInt32())
                .Should()
                .Be(0x00010010);

            state.EventState
                .Should()
                .Be(SCRState.Empty, "EventState should not change by setting the Counter");
            
            //Set the maximum value
            state.CardChangeEventCnt = 65535;
            state.CardChangeEventCnt
                .Should()
                .Be(65535);
            ((uint) state.EventStateValue.ToInt32())
                .Should().Be(0xFFFF0010);
            
            //try to set a value that is too high
            ((Action) (() => state.CardChangeEventCnt = 65536))
                .ShouldThrow<ArgumentException>();
            
            //try to set a negative value
            ((Action) (() => state.CardChangeEventCnt = -1))
                .ShouldThrow<ArgumentException>();
        }
        public SCardReaderState Status(out byte[] byteATR, out SCardReaderState eState, out SCardProtocolIdentifiers eProtocol)
        {
            if (this.m_fDisposed)
            {
                throw new ObjectDisposedException(base.GetType().FullName);
            }
            if (this.m_hCard == IntPtr.Zero)
            {
                throw new InvalidOperationException();
            }
            StringBuilder builder1 = new StringBuilder(0x100);
            uint          num3     = (uint)builder1.Capacity;

            byte[] atr  = new byte[0x20];
            uint   num4 = (uint)atr.Length;
            uint   dwState;
            uint   dwProtocol;
            uint   dwATRLength = (uint)atr.Length;

            uint num5 = WinSCard.SCardStatus(this.m_hCard, builder1, ref num3 /*builder1.Capacity*/, out dwState /*pdwState*/, out dwProtocol /*pdwProtocol*/, atr /*pbATR*/, ref dwATRLength /*pbcATRLen*/);

            if (num5 != 0)
            {
                //SmartCardException.RaiseWin32ResponseCode(num5);
            }
            eState    = (SCardReaderState)dwState;
            eProtocol = (SCardProtocolIdentifiers)dwProtocol;
            if (dwATRLength > 0)
            {
                // copy only the valid portion of the ATR to the return buffer.
                byteATR = new byte[dwATRLength];
                for (int i = 0; i < dwATRLength; i++)
                {
                    byteATR[i] = atr[i];
                }
            }
            else
            {
                byteATR    = new byte[1];
                byteATR[0] = 0;// return an invalid state.
            }

            return((SCardReaderState)dwState);
        }
        public void CardChangeEventCntSetEventStateValueTest() {
            var state = new SCardReaderState {
                EventStateValue = IntPtr.Zero
            };
            state.CardChangeEventCnt
                .Should()
                .Be(0);

            //set the counter (upper 2 bytes of the event state) to 1
            state.EventStateValue = unchecked (new IntPtr(0x00010000));
            state.CardChangeEventCnt
                .Should()
                .Be(1);

            //Set the maximum value
            state.EventStateValue = unchecked(new IntPtr(0xFFFF0000));
            state.CardChangeEventCnt
                .Should()
                .Be(65535);
        }
Exemple #13
0
        public void CardChangeEventCntSetEventStateValueTest()
        {
            var state = new SCardReaderState {
                EventStateValue = IntPtr.Zero
            };

            state.CardChangeEventCnt
            .Should()
            .Be(0);

            //set the counter (upper 2 bytes of the event state) to 1
            state.EventStateValue = unchecked (new IntPtr(0x00010000));
            state.CardChangeEventCnt
            .Should()
            .Be(1);

            //Set the maximum value
            state.EventStateValue = unchecked (new IntPtr(0xFFFF0000));
            state.CardChangeEventCnt
            .Should()
            .Be(65535);
        }
Exemple #14
0
        public SCardError GetStatusChange(
            IntPtr hContext,
            IntPtr dwTimeout,
            SCardReaderState[] rgReaderStates)
        {
            SCARD_READERSTATE[] readerstates = null;
            int cReaders = 0;

            if (rgReaderStates != null)
            {
                cReaders = rgReaderStates.Length;
                readerstates = new SCARD_READERSTATE[cReaders];
                for (int i = 0; i < cReaders; i++)
                    readerstates[i] = rgReaderStates[i].pcsclite_rstate;
            }
            IntPtr retval = SCardGetStatusChange(
                    (IntPtr)hContext,
                    (IntPtr)dwTimeout,
                    readerstates,
                    (IntPtr)cReaders);
            SCardError rc = SCardHelper.ToSCardError(retval);
            if (rc == SCardError.Success)
                if (rgReaderStates != null)
                {
                    for (int i = 0; i < cReaders; i++)
                        /* replace with returned values */
                        rgReaderStates[i].pcsclite_rstate = readerstates[i];
                }

            return rc;
        }
Exemple #15
0
        public SCardError GetStatusChange(IntPtr hContext, IntPtr dwTimeout, SCardReaderState[] rgReaderStates) {
            SCARD_READERSTATE[] readerstates = null;
            var cReaders = 0;

            if (rgReaderStates != null) {
                // copy the last known state into the buffer
                cReaders = rgReaderStates.Length;
                readerstates = new SCARD_READERSTATE[cReaders];
                for (var i = 0; i < cReaders; i++) {
                    readerstates[i] = rgReaderStates[i].UnixReaderState;
                }
            }

            var rc = SCardHelper.ToSCardError(SCardGetStatusChange(
                hContext,
                dwTimeout,
                readerstates,
                (IntPtr) cReaders));

            if (rc != SCardError.Success || rgReaderStates == null) {
                return rc;
            }

            for (var i = 0; i < cReaders; i++)
                // replace with returned values 
                rgReaderStates[i].UnixReaderState = readerstates[i];

            return rc;
        }
Exemple #16
0
        public SCardError GetStatusChange(IntPtr hContext, IntPtr dwTimeout, SCardReaderState[] rgReaderStates) {
            SCARD_READERSTATE[] readerstates = null;
            var cReaders = 0;

            if (rgReaderStates != null) {
                // copy the last known state into the buffer
                cReaders = rgReaderStates.Length;
                readerstates = new SCARD_READERSTATE[cReaders];
                for (var i = 0; i < cReaders; i++) {
                    readerstates[i] = rgReaderStates[i].WindowsReaderState;
                }
            }

            // On a 64-bit platforms .ToInt32() will throw an OverflowException 
            var timeout = unchecked((Int32) dwTimeout.ToInt64());
            var rc = SCardHelper.ToSCardError(
                SCardGetStatusChange(
                    hContext,
                    timeout,
                    readerstates,
                    cReaders));

            if (rc != SCardError.Success || rgReaderStates == null) {
                return rc;
            }

            for (var i = 0; i < cReaders; i++) {
                // replace with returned values
                rgReaderStates[i].WindowsReaderState = readerstates[i];
            }

            return rc;
        }
Exemple #17
0
        public SCardError GetStatusChange(
            IntPtr hContext,
            IntPtr dwTimeout,
            SCardReaderState[] rgReaderStates)
        {
            SCARD_READERSTATE[] readerstates = null;
            int cReaders = 0;

            if (rgReaderStates != null)
            {
                cReaders = rgReaderStates.Length;
                readerstates = new SCARD_READERSTATE[cReaders];
                for (int i = 0; i < cReaders; i++)
                    readerstates[i] = rgReaderStates[i].winscard_rstate;
            }

            SCardError rc;
            // On a 64-bit platforms .ToInt32() will throw an OverflowException
            Int32 timeout = unchecked((Int32)dwTimeout.ToInt64());
            rc = SCardHelper.ToSCardError(
                SCardGetStatusChange(
                    (IntPtr)hContext,
                    (Int32)timeout,
                    readerstates,
                    (Int32)cReaders));

            if (rc == SCardError.Success)
                if (rgReaderStates != null)
                {
                    for (int i = 0; i < cReaders; i++)
                        /* replace with returned values */
                        rgReaderStates[i].winscard_rstate = readerstates[i];
                }

            return rc;
        }
Exemple #18
0
        private void StartMonitor(Monitor monitor)
        {
            var readerStates = new SCardReaderState[monitor.ReaderNames.Length];

            for (var i = 0; i < monitor.ReaderNames.Length; i++)
            {
                readerStates[i] = new SCardReaderState {
                    ReaderName   = monitor.ReaderNames[i],
                    CurrentState = SCRState.Unaware
                };
            }

            var rc = monitor.Context.GetStatusChange(IntPtr.Zero, readerStates);

            if (rc == SCardError.Success)
            {
                // initialize event
                for (var i = 0; i < readerStates.Length; i++)
                {
                    var initState = readerStates[i].EventState & (~(SCRState.Changed));

                    OnInitialized(readerStates[i].Atr, monitor.ReaderNames[i], initState);

                    monitor.PreviousStates[i]      = initState; // remove "Changed"
                    monitor.PreviousStateValues[i] = readerStates[i].EventStateValue;
                }

                while (!_isDisposed && !monitor.CancelRequested)
                {
                    for (var i = 0; i < readerStates.Length; i++)
                    {
                        readerStates[i].CurrentStateValue = monitor.PreviousStateValues[i];
                    }

                    // block until status change occurs
                    rc = monitor.Context.GetStatusChange(monitor.Context.Infinite, readerStates);

                    // Cancel?
                    if (rc != SCardError.Success)
                    {
                        break;
                    }

                    for (var i = 0; i < readerStates.Length; i++)
                    {
                        var newState = readerStates[i].EventState;
                        newState &= (~(SCRState.Changed)); // remove "Changed"

                        var atr           = readerStates[i].Atr;
                        var previousState = monitor.PreviousStates[i];
                        var readerName    = monitor.ReaderNames[i];

                        // Status change
                        if (previousState != newState)
                        {
                            OnStatusChanged(atr, readerName, previousState, newState);
                        }

                        // Card inserted
                        if (newState.CardIsPresent() && previousState.CardIsAbsent())
                        {
                            OnCardInserted(atr, readerName, newState);
                        }

                        // Card removed
                        if (newState.CardIsAbsent() && previousState.CardIsPresent())
                        {
                            OnCardRemoved(atr, readerName, newState);
                        }

                        monitor.PreviousStates[i]      = newState;
                        monitor.PreviousStateValues[i] = readerStates[i].EventStateValue;
                    }
                }
            }

            foreach (var state in readerStates)
            {
                state.Dispose();
            }

            if (_isDisposed || monitor.CancelRequested || rc == SCardError.Cancelled)
            {
                return;
            }

            OnMonitorException(rc, "An error occured during SCardGetStatusChange(..).");
        }