Click here to Skip to main content
13,706,913 members
Click here to Skip to main content

Stats

1.7M views
122.9K downloads
332 bookmarked
Posted 5 Dec 2006
Licenced CPOL

A Smart Card Framework for .NET

, 15 May 2015
Describes a framework to use the PCSC Smart Card API with .NET.
Interop.GemCardExLib.dll
Interop.SCARDSSPLib.dll
DemoSCFmwk.exe
GemCard.dll
GemCardEx.dll
smartcardapi_doc
banner.jpg
darkcorner.jpg
GemCard
CWP0.HTM
CWP10.HTM
CWP100.HTM
CWP101.HTM
CWP102.HTM
CWP103.HTM
CWP105.HTM
CWP106.HTM
CWP107.HTM
CWP108.HTM
CWP109.HTM
CWP11.HTM
CWP110.HTM
CWP111.HTM
CWP112.HTM
CWP113.HTM
CWP114.HTM
CWP115.HTM
CWP116.HTM
CWP117.HTM
CWP118.HTM
CWP119.HTM
CWP12.HTM
CWP120.HTM
CWP121.HTM
CWP122.HTM
CWP123.HTM
CWP124.HTM
CWP125.HTM
CWP126.HTM
CWP127.HTM
CWP128.HTM
CWP129.HTM
CWP13.HTM
CWP130.HTM
CWP131.HTM
CWP132.HTM
CWP133.HTM
CWP134.HTM
CWP135.HTM
CWP136.HTM
CWP137.HTM
CWP138.HTM
CWP139.HTM
CWP14.HTM
CWP140.HTM
CWP141.HTM
CWP142.HTM
CWP143.HTM
CWP144.HTM
CWP145.HTM
CWP146.HTM
CWP147.HTM
CWP148.HTM
CWP149.HTM
CWP15.HTM
CWP150.HTM
CWP151.HTM
CWP152.HTM
CWP153.HTM
CWP154.HTM
CWP155.HTM
CWP156.HTM
CWP157.HTM
CWP158.HTM
CWP159.HTM
CWP16.HTM
CWP160.HTM
CWP161.HTM
CWP162.HTM
CWP163.HTM
CWP164.HTM
CWP165.HTM
CWP166.HTM
CWP167.HTM
CWP168.HTM
CWP169.HTM
CWP17.HTM
CWP170.HTM
CWP171.HTM
CWP172.HTM
CWP173.HTM
CWP174.HTM
CWP175.HTM
CWP176.HTM
CWP177.HTM
CWP178.HTM
CWP179.HTM
CWP18.HTM
CWP180.HTM
CWP181.HTM
CWP182.HTM
CWP183.HTM
CWP184.HTM
CWP185.HTM
CWP186.HTM
CWP187.HTM
CWP188.HTM
CWP189.HTM
CWP19.HTM
CWP190.HTM
CWP191.HTM
CWP192.HTM
CWP193.HTM
CWP194.HTM
CWP195.HTM
CWP196.HTM
CWP197.HTM
CWP198.HTM
CWP199.HTM
CWP2.HTM
CWP20.HTM
CWP200.HTM
CWP201.HTM
CWP202.HTM
CWP203.HTM
CWP21.HTM
CWP22.HTM
CWP23.HTM
CWP24.HTM
CWP25.HTM
CWP26.HTM
CWP27.HTM
CWP28.HTM
CWP29.HTM
CWP3.HTM
CWP30.HTM
CWP31.HTM
CWP32.HTM
CWP33.HTM
CWP34.HTM
CWP35.HTM
CWP36.HTM
CWP37.HTM
CWP38.HTM
CWP39.HTM
CWP4.HTM
CWP40.HTM
CWP41.HTM
CWP42.HTM
CWP43.HTM
CWP44.HTM
CWP45.HTM
CWP46.HTM
CWP47.HTM
CWP48.HTM
CWP49.HTM
CWP5.HTM
CWP50.HTM
CWP51.HTM
CWP52.HTM
CWP53.HTM
CWP54.HTM
CWP55.HTM
CWP56.HTM
CWP57.HTM
CWP58.HTM
CWP59.HTM
CWP6.HTM
CWP60.HTM
CWP61.HTM
CWP62.HTM
CWP63.HTM
CWP64.HTM
CWP65.HTM
CWP66.HTM
CWP67.HTM
CWP68.HTM
CWP69.HTM
CWP7.HTM
CWP70.HTM
CWP71.HTM
CWP73.HTM
CWP74.HTM
CWP75.HTM
CWP76.HTM
CWP77.HTM
CWP78.HTM
CWP79.HTM
CWP8.HTM
CWP80.HTM
CWP81.HTM
CWP82.HTM
CWP83.HTM
CWP84.HTM
CWP85.HTM
CWP86.HTM
CWP87.HTM
CWP88.HTM
CWP89.HTM
CWP9.HTM
CWP90.HTM
CWP91.HTM
CWP92.HTM
CWP93.HTM
CWP94.HTM
CWP95.HTM
CWP96.HTM
CWP97.HTM
CWP98.HTM
CWP99.HTM
GemCard.HTM
gradleft.jpg
gradtop.jpg
graycorner.jpg
minus.jpg
plus.jpg
Solution_Smartcard Framework.HTM
titletile.jpg
Smartcard_API
DemoSCFmwk
Properties
GemCardEx
GemCardEx.aps
GemCardEx.def
GemCardEx.rgs
GemCardEx.suo
GemCardEx.vcproj
GemCardEx.vcproj.CORUSCANT.han.user
GemCardEx.vcproj.vspscc
GemCardExps.def
GemCardExPS.vcproj
Release
GemCardEx.dll
SCardDatabaseEx.rgs
Smartcard Framework 2005.suo
GemCard
GemCard.csproj.user
SmartcardFramework
DemoSCardService
bin
Release
obj
Properties
Service References
SCardNPService
configuration.svcinfo
configuration91.svcinfo
DemoSCardService.SCardNPService.APDUResponse.datasource
Reference.svcmap
SCardService
configuration.svcinfo
configuration91.svcinfo
DemoSCardService.SCardService.APDUResponse.datasource
Reference.svcmap
SCardServiceHost
bin
obj
Properties
Smartcard Framework 2010.suo
Smartcard Framework 2010.v11.suo
Smartcard_API
DemoSCFmwk
bin
x86
obj
x86
Properties
GemCard
bin
x64
x86
GemCard.csproj.user
obj
x64
x86
SmartCardPlayer
bin
x86
obj
x86
Properties
Smartcard_Test
ApduExchange
ApduExchange.csproj.user
App.ico
bin
x86
obj
x86
Thumbs.db
GSMHelper
bin
x86
obj
x86
Properties
ReadPhonebook
bin
x86
obj
x86
Properties
ReadPhonebook.csproj.user
SmartcardService
bin
obj
Properties
SmartcardService.csproj.user
Smartcard_Framework_2010
Smartcard Framework 2010.suo
Smartcard_API
DemoSCFmwk
DemoSCFmwk.csproj.user
Properties
GemCard
GemCard.csproj.user
SmartCardPlayer
Properties
Smartcard_Test
ApduExchange
ApduExchange.csproj.user
App.ico
GSMHelper
Properties
ReadPhonebook
Properties
ReadPhonebook.csproj.user
Smartcard_Framework
Smartcard_API
DemoSCFmwk
Properties
GemCard
GemCard.csproj.user
SmartCardPlayer
Properties
Smartcard_Test
ApduExchange
ApduExchange.csproj.user
App.ico
GSMHelper
Properties
ReadPhonebook
Properties
ReadPhonebook.csproj.user
using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace GemCard
{
    /// <summary>
    /// CARD_STATE enumeration, used by the PC/SC function SCardGetStatusChanged
    /// </summary>
    enum CARD_STATE
    {
        UNAWARE = 0x00000000,
        IGNORE = 0x00000001,
        CHANGED = 0x00000002,
        UNKNOWN = 0x00000004,
        UNAVAILABLE = 0x00000008,
        EMPTY = 0x00000010,
        PRESENT = 0x00000020,
        ATRMATCH = 0x00000040,
        EXCLUSIVE = 0x00000080,
        INUSE = 0x00000100,
        MUTE = 0x00000200,
        UNPOWERED = 0x00000400
    }

	/// <summary>
	/// Wraps the SCARD_IO_STRUCTURE
    ///  
	/// </summary>
	[StructLayout(LayoutKind.Sequential)]
	public struct	SCard_IO_Request
	{
		public UInt32	m_dwProtocol;
		public UInt32	m_cbPciLength;
	}


    /// <summary>
    /// Wraps theSCARD_READERSTATE structure of PC/SC
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct SCard_ReaderState
    {
        public string m_szReader;
        public IntPtr m_pvUserData;
        public UInt32 m_dwCurrentState;
        public UInt32 m_dwEventState;
        public UInt32 m_cbAtr;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst=32)]
        public byte[] m_rgbAtr;
    }

	/// <summary>
	/// Implementation of ICard using native (P/Invoke) interoperability for PC/SC
	/// </summary>
	public class CardNative : CardBase
	{
		private	UInt32	m_hContext = 0;
		private	UInt32	m_hCard = 0;
		private	UInt32	m_nProtocol = (uint) PROTOCOL.T0;
		private	int	m_nLastError = 0;

		#region PCSC_FUNCTIONS
        /// <summary>
        /// Native SCardGetStatusChanged from winscard.dll
        /// </summary>
        /// <param name="hContext"></param>
        /// <param name="dwTimeout"></param>
        /// <param name="rgReaderStates"></param>
        /// <param name="cReaders"></param>
        /// <returns></returns>
        [DllImport("winscard.dll", SetLastError = true)]
        internal static extern int SCardGetStatusChange(UInt32 hContext,
            UInt32 dwTimeout,
            [In,Out] SCard_ReaderState[] rgReaderStates,
            UInt32 cReaders);

		/// <summary>
		/// Native SCardListReaders function from winscard.dll
		/// </summary>
		/// <param name="hContext"></param>
		/// <param name="mszGroups"></param>
		/// <param name="mszReaders"></param>
		/// <param name="pcchReaders"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true)]
		internal static extern int SCardListReaders(UInt32 hContext,
			[MarshalAs(UnmanagedType.LPTStr)] string mszGroups,
			IntPtr mszReaders,
			out UInt32	pcchReaders);

		/// <summary>
		/// Native SCardEstablishContext function from winscard.dll
		/// </summary>
		/// <param name="dwScope"></param>
		/// <param name="pvReserved1"></param>
		/// <param name="pvReserved2"></param>
		/// <param name="phContext"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true)]
		internal	static	extern	int	SCardEstablishContext(UInt32 dwScope,
			IntPtr pvReserved1,
			IntPtr pvReserved2,
			IntPtr phContext);

		/// <summary>
		/// Native SCardReleaseContext function from winscard.dll
		/// </summary>
		/// <param name="hContext"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true)]
		internal static extern	int	SCardReleaseContext(UInt32 hContext);

		/// <summary>
		/// Native SCardConnect function from winscard.dll
		/// </summary>
		/// <param name="hContext"></param>
		/// <param name="szReader"></param>
		/// <param name="dwShareMode"></param>
		/// <param name="dwPreferredProtocols"></param>
		/// <param name="phCard"></param>
		/// <param name="pdwActiveProtocol"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true, CharSet=CharSet.Auto)]
		internal static	extern	int	SCardConnect(UInt32 hContext,
			[MarshalAs(UnmanagedType.LPTStr)] string szReader,
			UInt32	dwShareMode, 
			UInt32	dwPreferredProtocols,
			IntPtr	phCard, 
			IntPtr	pdwActiveProtocol);

		/// <summary>
		/// Native SCardDisconnect function from winscard.dll
		/// </summary>
		/// <param name="hCard"></param>
		/// <param name="dwDisposition"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true)]
		internal static extern	int	SCardDisconnect(UInt32 hCard,
			UInt32 dwDisposition);

		/// <summary>
		/// Native SCardTransmit function from winscard.dll
		/// </summary>
		/// <param name="hCard"></param>
		/// <param name="pioSendPci"></param>
		/// <param name="pbSendBuffer"></param>
		/// <param name="cbSendLength"></param>
		/// <param name="pioRecvPci"></param>
		/// <param name="pbRecvBuffer"></param>
		/// <param name="pcbRecvLength"></param>
		/// <returns></returns>
		[DllImport("winscard.dll", SetLastError=true)]
		internal static extern	int	SCardTransmit(UInt32 hCard,
			[In] ref SCard_IO_Request pioSendPci,
			byte[] pbSendBuffer,
			UInt32 cbSendLength,
			IntPtr pioRecvPci,
			[Out] byte[] pbRecvBuffer,
			out UInt32 pcbRecvLength
			);

        /// <summary>
        /// Native SCardBeginTransaction function of winscard.dll
        /// </summary>
        /// <param name="hContext"></param>
        /// <returns></returns>
        [DllImport("winscard.dll", SetLastError = true)]
        internal static extern int SCardBeginTransaction(UInt32 hContext);

        /// <summary>
        /// Native SCardEndTransaction function of winscard.dll
        /// </summary>
        /// <param name="hContext"></param>
        /// <returns></returns>
        [DllImport("winscard.dll", SetLastError = true)]
        internal static extern int SCardEndTransaction(UInt32 hContext, UInt32 dwDisposition);

        [DllImport("winscard.dll", SetLastError = true)]
        internal static extern int SCardGetAttrib(UInt32 hCard,
            UInt32 dwAttribId,
            [Out] byte[] pbAttr,
            out UInt32 pcbAttrLen);

        #endregion WINSCARD_FUNCTIONS

		/// <summary>
		/// Default constructor
		/// </summary>
		public CardNative()
		{
		}

		/// <summary>
		/// Object destruction
		/// </summary>
		~CardNative()
		{
			Disconnect(DISCONNECT.Unpower);

			ReleaseContext();
		}

		#region ICard Members

		/// <summary>
		/// Wraps the PCSC function
		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
		///		LPCTSTR mszGroups, 
		///		LPTSTR mszReaders, 
		///		LPDWORD pcchReaders 
		///	);
		/// </summary>
		/// <returns>A string array of the readers</returns>
		public	override string[]	ListReaders()
		{
			EstablishContext(SCOPE.User);

			string[]	sListReaders = null;
			UInt32	pchReaders = 0;
			IntPtr	szListReaders = IntPtr.Zero;

			m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
			if (m_nLastError == 0)
			{
				szListReaders = Marshal.AllocHGlobal((int) pchReaders);
				m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
				if (m_nLastError == 0)
				{
					char[] caReadersData = new char[pchReaders];
					int	nbReaders = 0;
					for (int nI = 0; nI < pchReaders; nI++)
					{
						caReadersData[nI] = (char) Marshal.ReadByte(szListReaders, nI);

						if (caReadersData[nI] == 0)
							nbReaders++;
					}

					// Remove last 0
					--nbReaders;

					if (nbReaders != 0)
					{
						sListReaders = new string[nbReaders];
						char[] caReader = new char[pchReaders];
						int	nIdx = 0;
						int	nIdy = 0;
						int	nIdz = 0;
						// Get the nJ string from the multi-string

						while(nIdx < pchReaders - 1)
						{
							caReader[nIdy] = caReadersData[nIdx];
							if (caReader[nIdy] == 0)
							{
								sListReaders[nIdz] = new string(caReader, 0, nIdy);
								++nIdz;
								nIdy = 0;
								caReader = new char[pchReaders];
							}
							else
								++nIdy;

							++nIdx;
						}
					}

				}

				Marshal.FreeHGlobal(szListReaders);
			}

			ReleaseContext();

			return sListReaders;
		}

		/// <summary>
		/// Wraps the PCSC function 
		/// LONG SCardEstablishContext(
		///		IN DWORD dwScope,
		///		IN LPCVOID pvReserved1,
		///		IN LPCVOID pvReserved2,
		///		OUT LPSCARDCONTEXT phContext
		///	);
		/// </summary>
		/// <param name="Scope"></param>
		public void EstablishContext(SCOPE Scope)
		{
			IntPtr	hContext = Marshal.AllocHGlobal(Marshal.SizeOf(m_hContext));

			m_nLastError = SCardEstablishContext((uint) Scope, IntPtr.Zero, IntPtr.Zero, hContext);
			if (m_nLastError != 0)
			{
				string msg = "SCardEstablishContext error: " + m_nLastError;

				Marshal.FreeHGlobal(hContext);
				throw new Exception(msg);
			}

			m_hContext = (uint) Marshal.ReadInt32(hContext);

			Marshal.FreeHGlobal(hContext);
		}


		/// <summary>
		/// Wraps the PCSC function
		/// LONG SCardReleaseContext(
		///		IN SCARDCONTEXT hContext
		///	);
		/// </summary>
		public void ReleaseContext()
		{
			if (m_hContext != 0)
			{
				m_nLastError = SCardReleaseContext(m_hContext);

				if (m_nLastError != 0)
				{
					string	msg = "SCardReleaseContext error: " + m_nLastError;
					throw new Exception(msg);
				}

				m_hContext = 0;
			}
		}

		/// <summary>
		///  Wraps the PCSC function
		///  LONG SCardConnect(
		///		IN SCARDCONTEXT hContext,
		///		IN LPCTSTR szReader,
		///		IN DWORD dwShareMode,
		///		IN DWORD dwPreferredProtocols,
		///		OUT LPSCARDHANDLE phCard,
		///		OUT LPDWORD pdwActiveProtocol
		///	);
		/// </summary>
		/// <param name="Reader"></param>
		/// <param name="ShareMode"></param>
		/// <param name="PreferredProtocols"></param>
		public override void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols)
		{
			EstablishContext(SCOPE.User);

			IntPtr	hCard = Marshal.AllocHGlobal(Marshal.SizeOf(m_hCard));
			IntPtr	pProtocol = Marshal.AllocHGlobal(Marshal.SizeOf(m_nProtocol));

			m_nLastError = SCardConnect(m_hContext, 
				Reader, 
				(uint) ShareMode, 
				(uint) PreferredProtocols, 
				hCard,
				pProtocol);

			if (m_nLastError != 0)
			{
				string msg = "SCardConnect error: " + m_nLastError;

				Marshal.FreeHGlobal(hCard);
				Marshal.FreeHGlobal(pProtocol);
				throw new Exception(msg);
			}

			m_hCard = (uint) Marshal.ReadInt32(hCard);
			m_nProtocol = (uint) Marshal.ReadInt32(pProtocol);

			Marshal.FreeHGlobal(hCard);
			Marshal.FreeHGlobal(pProtocol);
		}

		/// <summary>
		/// Wraps the PCSC function
		///	LONG SCardDisconnect(
		///		IN SCARDHANDLE hCard,
		///		IN DWORD dwDisposition
		///	);
		/// </summary>
		/// <param name="Disposition"></param>
		public override void Disconnect(DISCONNECT Disposition)
		{
			if (m_hCard != 0)
			{
				m_nLastError = SCardDisconnect(m_hCard, (uint) Disposition);
				m_hCard = 0;

				if (m_nLastError != 0)
				{
					string msg = "SCardDisconnect error: " + m_nLastError;
					throw new Exception(msg);
				}

				ReleaseContext();
			}
		}

		/// <summary>
		/// Wraps the PCSC function
		/// LONG SCardTransmit(
		///		SCARDHANDLE hCard,
		///		LPCSCARD_I0_REQUEST pioSendPci,
		///		LPCBYTE pbSendBuffer,
		///		DWORD cbSendLength,
		///		LPSCARD_IO_REQUEST pioRecvPci,
		///		LPBYTE pbRecvBuffer,
		///		LPDWORD pcbRecvLength
		///	);
		/// </summary>
		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
		/// <returns>An APDUResponse object with the response from the card</returns>
		public override APDUResponse Transmit(APDUCommand ApduCmd)
		{
			uint	RecvLength = (uint) (ApduCmd.Le + APDUResponse.SW_LENGTH);
			byte[]	ApduBuffer = null;
			byte[]	ApduResponse = new byte[ApduCmd.Le + APDUResponse.SW_LENGTH];
			SCard_IO_Request	ioRequest = new SCard_IO_Request();
			ioRequest.m_dwProtocol = m_nProtocol;
			ioRequest.m_cbPciLength = 8;

			// Build the command APDU
			if (ApduCmd.Data == null)
			{
				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + ((ApduCmd.Le != 0) ? 1 : 0)];

				if (ApduCmd.Le != 0)
					ApduBuffer[4] = (byte) ApduCmd.Le;
			}
			else
			{
				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + 1 + ApduCmd.Data.Length];

				for (int nI = 0; nI < ApduCmd.Data.Length; nI++)
					ApduBuffer[APDUCommand.APDU_MIN_LENGTH + 1 + nI] = ApduCmd.Data[nI];

				ApduBuffer[APDUCommand.APDU_MIN_LENGTH] = (byte) ApduCmd.Data.Length;
			}

			ApduBuffer[0] = ApduCmd.Class;
			ApduBuffer[1] = ApduCmd.Ins;
			ApduBuffer[2] = ApduCmd.P1;
			ApduBuffer[3] = ApduCmd.P2;

			m_nLastError = SCardTransmit(m_hCard, ref ioRequest, ApduBuffer, (uint) ApduBuffer.Length, IntPtr.Zero, ApduResponse, out RecvLength); 
			if (m_nLastError != 0)
			{
				string msg = "SCardTransmit error: " + m_nLastError;
				throw new Exception(msg);
			}
			
			byte[] ApduData = new byte[RecvLength];

			for (int nI = 0; nI < RecvLength; nI++)
				ApduData[nI] = ApduResponse[nI];

			return new APDUResponse(ApduData);
		}


        /// <summary>
        /// Wraps the PSCS function
        /// LONG SCardBeginTransaction(
        ///     SCARDHANDLE hCard
        //  );
        /// </summary>
        public override void BeginTransaction()
        {
            if (m_hCard != 0)
            {
                m_nLastError = SCardBeginTransaction(m_hCard);
                if (m_nLastError != 0)
                {
                    string msg = "SCardBeginTransaction error: " + m_nLastError;
                    throw new Exception(msg);
                }
            }
        }

        /// <summary>
        /// Wraps the PCSC function
        /// LONG SCardEndTransaction(
        ///     SCARDHANDLE hCard,
        ///     DWORD dwDisposition
        /// );
        /// </summary>
        /// <param name="Disposition">A value from DISCONNECT enum</param>
        public override void EndTransaction(DISCONNECT Disposition)
        {
            if (m_hCard != 0)
            {
                m_nLastError = SCardEndTransaction(m_hCard, (UInt32)Disposition);
                if (m_nLastError != 0)
                {
                    string msg = "SCardEndTransaction error: " + m_nLastError;
                    throw new Exception(msg);
                }
            }
        }

        /// <summary>
        /// Gets the attributes of the card
        /// </summary>
        /// <param name="AttribId">Identifier for the Attribute to get</param>
        /// <returns>Attribute content</returns>
        public override byte[] GetAttribute(UInt32 AttribId)
        {
            byte[] attr = null;
            UInt32 attrLen = 0;

            m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
            if (m_nLastError == 0)
            {
                if (attrLen != 0)
                {
                    attr = new byte[attrLen];
                    m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
                    if (m_nLastError != 0)
                    {
                        string msg = "SCardGetAttr error: " + m_nLastError;
                        throw new Exception(msg);
                    }
                }
            }
            else
            {
                string msg = "SCardGetAttr error: " + m_nLastError;
                throw new Exception(msg);
            }

            return attr;
        }
        #endregion

        /// <summary>
        /// This function must implement a card detection mechanism.
        /// 
        /// When card insertion is detected, it must call the method CardInserted()
        /// When card removal is detected, it must call the method CardRemoved()
        /// 
        /// </summary>
        protected override void RunCardDetection(object Reader)
        {
            bool bFirstLoop = true;
            UInt32 hContext = 0;    // Local context
            IntPtr phContext;

            phContext = Marshal.AllocHGlobal(Marshal.SizeOf(hContext));

            if (SCardEstablishContext((uint) SCOPE.User, IntPtr.Zero, IntPtr.Zero, phContext) == 0)
            {
                hContext = (uint)Marshal.ReadInt32(phContext);
                Marshal.FreeHGlobal(phContext);

                UInt32 nbReaders = 1;
                SCard_ReaderState[] readerState = new SCard_ReaderState[nbReaders];

                readerState[0].m_dwCurrentState = (UInt32) CARD_STATE.UNAWARE;
                readerState[0].m_szReader = (string)Reader;

                UInt32 eventState;
                UInt32 currentState = readerState[0].m_dwCurrentState;

                // Card detection loop
                do
                {
                    if (SCardGetStatusChange(hContext, WAIT_TIME
                        , readerState, nbReaders) == 0)
                    {
                        eventState = readerState[0].m_dwEventState;
                        currentState = readerState[0].m_dwCurrentState;

                        // Check state
                        if (((eventState & (uint) CARD_STATE.CHANGED) == (uint) CARD_STATE.CHANGED) && !bFirstLoop)    
                        {
                            // State has changed
                            if ((eventState & (uint) CARD_STATE.EMPTY) == (uint) CARD_STATE.EMPTY)
                            {
                                // There is no card, card has been removed -> Fire CardRemoved event
                                CardRemoved();
                            }

                            if (((eventState & (uint)CARD_STATE.PRESENT) == (uint)CARD_STATE.PRESENT) && 
                                ((eventState & (uint) CARD_STATE.PRESENT) != (currentState & (uint) CARD_STATE.PRESENT)))
                            {
                                // There is a card in the reader -> Fire CardInserted event
                                CardInserted();
                            }

                            if ((eventState & (uint) CARD_STATE.ATRMATCH) == (uint) CARD_STATE.ATRMATCH)
                            {
                                // There is a card in the reader and it matches the ATR we were expecting-> Fire CardInserted event
                                CardInserted();
                            }
                        }

                        // The current stateis now the event state
                        readerState[0].m_dwCurrentState = eventState;

                        bFirstLoop = false;
                    }

                    Thread.Sleep(100);

                    if (m_bRunCardDetection == false)
                        break;
                }
                while (true);    // Exit on request
            }
            else
            {
                Marshal.FreeHGlobal(phContext);
                throw new Exception("PC/SC error");
            }

            SCardReleaseContext(hContext);
        }
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

orouit
Architect Connect In Private
Singapore Singapore
Software Architect, COM, .NET and Smartcard based security specialist.

I've been working in the software industry since I graduated in Electrical and Electronics Engineering. I chose software because I preferred digital to analog.

I started to program with 6802 machine code and evolved to the current .NET technologies... that was a long way.

For more than 20 years I have always worked in technical positions as I simply like to get my hands dirty and crack my brain when things don't go right!

After 12 years in the smart card industry I can claim a strong knowledge in security solutions based on those really small computers!
I've been back into business to design the licensing system for the enterprise solution for Consistel using a .NET smart card (yes they can run .NET CLR!)

I'm currently designing a micro-payment solution using the NXP DESFire EV1 with the ACSO6 SAM of ACS. I can then add a full proficient expertise on those systems and NFC payments.
This technology being under strict NDA by NXP I cannot publish any related article about it, however I can provide professional consulting for it.

You can contact me for professional matter by using the forum or via my LinkedIn profile.

You may also be interested in...

Pro
Pro
Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web06-2016 | 2.8.180920.1 | Last Updated 15 May 2015
Article Copyright 2006 by orouit
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid