public SCardError Reconnect(SCardShareMode mode,
SCardProtocol prefProto,
SCardReaderDisposition initExec)
{
if (cardHandle.Equals(IntPtr.Zero))
{
throw new InvalidOperationException(
"Reader is currently not connected or no card handle has been returned.");
}
SCardProtocol dwActiveProtocol = activeprot;
SCardError rc = SCardAPI.Lib.Reconnect(cardHandle,
mode,
prefProto,
initExec,
out dwActiveProtocol);
if (rc == SCardError.Success)
{
activeprot = dwActiveProtocol;
sharemode = mode;
}
return(rc);
}
public SCardError Connect(
IntPtr hContext,
string szReader,
SCardShareMode dwShareMode,
SCardProtocol dwPreferredProtocols,
out IntPtr phCard,
out SCardProtocol pdwActiveProtocol)
{
byte[] readername = SCardHelper._ConvertToByteArray(szReader, textEncoding, SCardAPI.Lib.CharSize);
Int32 sharemode = (Int32)dwShareMode;
Int32 prefproto = (Int32)dwPreferredProtocols;
IntPtr ctx = (IntPtr)hContext;
IntPtr card;
Int32 activeproto;
Int32 result = SCardConnect(ctx,
readername,
sharemode,
prefproto,
out card,
out activeproto);
phCard = card;
pdwActiveProtocol = (SCardProtocol)activeproto;
return(SCardHelper.ToSCardError(result));
}
/// <inheritdoc />
public void Connect(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
ThrowIfDisposed();
ThrowIfAlreadyConnected();
if (readerName == null)
{
throw new ArgumentNullException(nameof(readerName));
}
if (string.IsNullOrWhiteSpace(readerName))
{
throw new UnknownReaderException(SCardError.InvalidValue, "Invalid card reader name.");
}
if (_context.Handle.Equals(IntPtr.Zero))
{
throw new InvalidContextException(SCardError.InvalidHandle, "Invalid connection context.");
}
_api.Connect(
hContext: _context.Handle,
szReader: readerName,
dwShareMode: mode,
dwPreferredProtocols: preferredProtocol,
phCard: out var cardHandle,
pdwActiveProtocol: out var activeProtocol)
.ThrowIfNotSuccess();
Handle = cardHandle;
Protocol = activeProtocol;
Mode = mode;
ReaderName = readerName;
}
public IsoCard(ISCardReader reader, string readerName, SCardShareMode mode, SCardProtocol proto)
{
if (reader == null)
throw new ArgumentNullException("reader");
this.reader = reader;
Connect(readerName, mode, proto);
}
/// <inheritdoc />
public ICardHandle Connect(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
ThrowOnInvalidContext();
var handle = new CardHandle(_api, this);
handle.Connect(readerName, mode, preferredProtocol);
return(handle);
}
public IsoCard(ISCardReader reader, string readerName, SCardShareMode mode, SCardProtocol proto)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
this.reader = reader;
Connect(readerName, mode, proto);
}
public SCardError Reconnect(IntPtr hCard, SCardShareMode dwShareMode, SCardProtocol dwPreferredProtocols, SCardReaderDisposition dwInitialization, out SCardProtocol pdwActiveProtocol)
{
var result = SCardReconnect(
hCard,
(int)dwShareMode,
(int)dwPreferredProtocols,
(int)dwInitialization,
out var activeproto);
pdwActiveProtocol = (SCardProtocol)activeproto;
return(SCardHelper.ToSCardError(result));
}
/// <summary>
/// Creates a new <see cref="CCIDDriver"/> by connecting to the device specified by <paramref name="name"/>.
/// </summary>
/// <param name="name">Device name</param>
/// <param name="mode">Connection mode</param>
/// <param name="protocol">Connection protocol</param>
/// <returns>Returns a new <see cref="CCIDDriver"/> if the device was found.</returns>
/// <exception cref="ConnectionException">Thrown if the device is not found or may not be connected to at this time.</exception>
public static CCIDDriver OpenDevice(string name, SCardShareMode mode = SCardShareMode.Exclusive, SCardProtocol protocol = SCardProtocol.Any)
{
ISCardContext ctx = ContextFactory.Instance.Establish(SCardScope.System);
ISCardReader reader = new SCardReader(ctx);
if (reader.Connect(name, mode, protocol) != SCardError.Success)
{
throw new ConnectionException("Failed to connect to device.");
}
return(new CCIDDriver(ctx, reader));
}
public IntPtr Connect(string readerName, SCardShareMode shareMode, SCardProtocol protocol)
{
IntPtr CardHandle;
SCardProtocol ActiveProtocol;
SCardError Error = SCardApi.SCardConnect(this.Context, readerName, shareMode, protocol, out CardHandle, out ActiveProtocol);
if (SCardApi.IsError(Error))
{
throw new SCardException(Error);
}
SCardApi.sessionProtocols.Add(CardHandle, protocol);
return(CardHandle);
}
public virtual void Connect(string readerName, SCardShareMode mode, SCardProtocol proto)
{
if (readerName == null) // Invalid reader name?
throw new ArgumentNullException("readerName");
if (proto == SCardProtocol.Unset) // Invalid protocol?
throw new InvalidProtocolException(SCardError.InvalidValue);
if (((long)mode) == 0) // Invalid sharing mode?
throw new InvalidShareModeException(SCardError.InvalidValue);
SCardError sc = reader.Connect(readerName, mode, proto);
// Throws an exception if sc != SCardError.Success
ThrowExceptionOnSCardError(sc);
}
public SCardError Connect(IntPtr hContext, string szReader, SCardShareMode dwShareMode, SCardProtocol dwPreferredProtocols, out IntPtr phCard, out SCardProtocol pdwActiveProtocol)
{
var readername = SCardHelper.ConvertToByteArray(szReader, TextEncoding, Platform.Lib.CharSize);
var result = SCardConnect(hContext,
readername,
(int)dwShareMode,
(int)dwPreferredProtocols,
out phCard,
out var activeproto);
pdwActiveProtocol = (SCardProtocol)activeproto;
return(SCardHelper.ToSCardError(result));
}
public void Reconnect(IntPtr cardHandle, SCardDisposition disposition, SCardShareMode shareMode, SCardProtocol protocol)
{
if (disposition == SCardDisposition.Eject)
{
throw new ArgumentException("Disposition.Eject not possible in reconnect", nameof(disposition));
}
SCardProtocol ActiveProtocol;
SCardError Error = SCardApi.SCardReconnect(cardHandle, shareMode, protocol, disposition, out ActiveProtocol);
if (SCardApi.IsError(Error))
{
throw new SCardException(Error);
}
SCardApi.sessionProtocols.Remove(cardHandle);
SCardApi.sessionProtocols.Add(cardHandle, protocol);
}
/// <inheritdoc />
public void Reconnect(SCardShareMode mode, SCardProtocol preferredProtocol,
SCardReaderDisposition initialExecution)
{
ThrowIfDisposed();
ThrowOnInvalidCardHandle();
_api.Reconnect(
hCard: Handle,
dwShareMode: mode,
dwPreferredProtocols: preferredProtocol,
dwInitialization: initialExecution,
pdwActiveProtocol: out var dwActiveProtocol)
.ThrowIfNotSuccess();
Protocol = dwActiveProtocol;
Mode = mode;
}
public virtual void Connect(string readerName, SCardShareMode mode, SCardProtocol proto)
{
if (readerName == null) // Invalid reader name?
{
throw new ArgumentNullException("readerName");
}
if (proto == SCardProtocol.Unset) // Invalid protocol?
{
throw new InvalidProtocolException(SCardError.InvalidValue);
}
if (((long)mode) == 0) // Invalid sharing mode?
{
throw new InvalidShareModeException(SCardError.InvalidValue);
}
SCardError sc = reader.Connect(readerName, mode, proto);
// Throws an exception if sc != SCardError.Success
ThrowExceptionOnSCardError(sc);
}
/// <inheritdoc />
public SCardError Reconnect(SCardShareMode mode, SCardProtocol preferredProtocol,
SCardReaderDisposition initialExecution)
{
ThrowOnInvalidCardHandle();
var rc = Platform.Lib.Reconnect(_cardHandle,
mode,
preferredProtocol,
initialExecution,
out var dwActiveProtocol);
if (rc != SCardError.Success)
{
return(rc);
}
ActiveProtocol = dwActiveProtocol;
CurrentShareMode = mode;
return(rc);
}
/// <summary>Connects the specified reader.</summary>
/// <param name="readerName">Name of the reader.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
public virtual void Connect(string readerName, SCardShareMode mode, SCardProtocol protocol)
{
if (readerName == null)
{
throw new ArgumentNullException(nameof(readerName));
}
if (protocol == SCardProtocol.Unset)
{
throw new InvalidProtocolException(SCardError.InvalidValue);
}
if (((long)mode) == 0)
{
throw new InvalidShareModeException(SCardError.InvalidValue);
}
var sc = Reader.Connect(readerName, mode, protocol);
// Throws an exception if sc != SCardError.Success
sc.ThrowIfNotSuccess();
}
/// <inheritdoc />
public SCardError Connect(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
if (readerName == null)
{
throw new ArgumentNullException(nameof(readerName));
}
if (string.IsNullOrWhiteSpace(readerName))
{
throw new UnknownReaderException(SCardError.InvalidValue, "Invalid card reader name.");
}
if (CurrentContext == null || CurrentContext.Handle.Equals(IntPtr.Zero))
{
throw new InvalidContextException(SCardError.InvalidHandle, "Invalid connection context.");
}
var rc = Platform.Lib.Connect(CurrentContext.Handle,
readerName,
mode,
preferredProtocol,
out var hCard,
out var dwActiveProtocol);
if (rc != SCardError.Success)
{
return(rc);
}
_cardHandle = hCard;
ActiveProtocol = dwActiveProtocol;
ReaderName = readerName;
CurrentShareMode = mode;
return(rc);
}
public SCardError Connect(string name,
SCardShareMode mode,
SCardProtocol prefProto)
{
if (name == null ||
name.Equals(""))
{
throw new UnknownReaderException(SCardError.InvalidValue, "Invalid card reader name.");
}
if (context == null || context.contextPtr.Equals(IntPtr.Zero))
{
throw new InvalidContextException(SCardError.InvalidHandle, "Invalid connection context.");
}
SCardError rc;
IntPtr hCard = IntPtr.Zero;
SCardProtocol dwActiveProtocol;
rc = SCardAPI.Lib.Connect(context.contextPtr,
name,
mode,
prefProto,
out hCard,
out dwActiveProtocol);
if (rc == SCardError.Success)
{
cardHandle = hCard;
activeprot = dwActiveProtocol;
readername = name;
sharemode = mode;
}
return(rc);
}
public static extern PCSCResult SCardReconnect(IntPtr hCard, SCardShareMode dwShareMode,
SCardProtocol dwPrefProtocol, SCardDisposition dwInitialization, ref SCardProtocol ActiveProtocol);
public void Connect(SCardShareMode shareMode = SCardShareMode.Shared)
{
PCSCResult result;
// Are we already connected?
if (myHandle != IntPtr.Zero)
{
return;
}
// Establish a new session context for this card
result = NativeMethods.SCardEstablishContext(SCardScope.User, IntPtr.Zero, IntPtr.Zero, out myContext);
if (PCSCResult.None != result)
{
throw PCSCException.ThrowByResult(result);
}
// Connect to the card
result = NativeMethods.SCardConnect(myContext, myReaderName, shareMode, DefaultRequestedProtocols, ref myHandle, ref myCommsProtocol);
if (PCSCResult.None != result)
{
// Disconnect (this will gracefully handle the context release)
Disconnect();
throw PCSCException.ThrowByResult(result);
}
// Retrieve our ATR
byte[] readerName = new byte[255];
uint readerLen = 255;
SCardState state = 0;
SCardProtocol cardProtocol = 0;
uint atrLen = NativeMethods.SCARD_ATR_LENGTH;
byte[] atr = new byte[atrLen];
result = NativeMethods.SCardStatus(myHandle, readerName, ref readerLen, out state, out cardProtocol, atr, ref atrLen);
if (result != PCSCResult.None)
{
// Disconnect from the card
Disconnect();
throw PCSCException.ThrowByResult(result);
}
//
// Protocol Enumeration
//
try
{
// Add the default 7816 protocol
Protocols.Add(new PCSCIso7816Protocol(atr, this));
// Determine whether this card is contactless or not
if (SupportsIso14443)
{
// Replace the 7816 protocol with 14443
Protocols.Clear();
var protocol = new PCSCIso14443AProtocol(atr, this);
Protocols.Add(protocol);
// Create our OptionalCommands object
OptionalCommands = new PCSCOptionalCommands(protocol);
//
// HACK: Adding a PCSCMifareProtocol to all ISO14443 cards, what
// we should be doing is somehow determining if this card
// supports Mifare or Mifare emulation
//
Protocols.Add(new PCSCMifareProtocol(this));
}
}
catch (Exception)
{
// Disconnect from the card
Disconnect();
throw PCSCException.ThrowUnsupportedProtocol();
}
}
public SCardError Connect(IntPtr hContext, string szReader, SCardShareMode dwShareMode, SCardProtocol dwPreferredProtocols, out IntPtr phCard, out SCardProtocol pdwActiveProtocol) {
var readername = SCardHelper.ConvertToByteArray(szReader, _textEncoding, Platform.Lib.CharSize);
IntPtr activeproto;
var result = SCardConnect(hContext,
readername,
(IntPtr) dwShareMode,
(IntPtr) dwPreferredProtocols,
out phCard,
out activeproto);
pdwActiveProtocol = (SCardProtocol) activeproto;
return SCardHelper.ToSCardError(result);
}
public SCardError Connect(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public ICardReader ConnectReader(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
var handle = Connect(readerName, mode, preferredProtocol);
return(new CardReader(_api, handle, true));
}
public SCardError Reconnect(SCardShareMode mode, SCardProtocol preferredProtocol, SCardReaderDisposition initialExecution)
{
throw new NotImplementedException();
}
/// <summary>
/// Connects to a card on the specified reader using the specified parameters.
/// </summary>
/// <param name="context">An IntPtr that is the context to use.</param>
/// <param name="readerName">A string containing the name of the reader to use.</param>
/// <param name="cardHandle">An IntPtr that will be set to the handle of the card.</param>
/// <param name="actualProtocol">A SCardProtocol that will be set to the established protocol.</param>
/// <param name="result">A SCardResponse that will be set to the result of the operation.</param>
/// <param name="shareMode">A SCardShareMode that indicates other applications can connect to the card.</param>
/// <param name="protocol">A SCardProtocol indicating the acceptable protocols to use for the connection.</param>
/// <returns>A bool that indicates whether the operation was a success.</returns>
internal static bool ConnectCard(IntPtr context, string readerName, out IntPtr cardHandle, out SCardProtocol actualProtocol, out SCardResponse result, SCardShareMode shareMode = SCardShareMode.Shared, SCardProtocol protocol = SCardProtocol.T0)
{
uint resultCode;
bool returnValue = false;
resultCode = SCardConnect(context, readerName, shareMode, protocol, out cardHandle, out actualProtocol);
result = (SCardResponse)resultCode;
if (result == SCardResponse.SCARD_S_SUCCESS)
{
returnValue = true;
}
return(returnValue);
}
/// <summary>Terminates a connection made through <see cref="M:PCSC.ISCardReader.Connect(System.String,PCSC.SCardShareMode,PCSC.SCardProtocol)" />.</summary>
/// <param name="disconnectExecution">Reader function to execute.</param>
/// <returns>
/// <list type="table">
/// <listheader>
/// <term>Return value</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.Success" />
/// </term>
/// <description>Successful (SCARD_S_SUCCESS)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidHandle" />
/// </term>
/// <description>Invalid card handle (SCARD_E_INVALID_HANDLE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidValue" />
/// </term>
/// <description>Invalid <paramref name="disconnectExecution" /> (SCARD_E_INVALID_VALUE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoService" />
/// </term>
/// <description>The server is not runing (SCARD_E_NO_SERVICE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoSmartcard" />
/// </term>
/// <description>No smart card present (SCARD_E_NO_SMARTCARD)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.CommunicationError" />
/// </term>
/// <description>An internal communications error has been detected (SCARD_F_COMM_ERROR)</description>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>This method calls the API function SCardDisconnect().</para>
/// <example>
/// <code lang="C#">
/// // Establish PC/SC context.
/// SCardContext ctx = new SCardContext();
/// ctx.Establish(SCardScope.System);
///
/// // Create a Smart Card reader object and connect to it.
/// ISCardReader reader = new SCardReader(ctx);
/// SCardError serr = reader.Connect("OMNIKEY", SCardShareMode.Shared, SCardProtocol.Any);
///
/// // Disconnect the reader and reset the SmartCard.
/// reader.Disconnect(SCardReaderDisposition.Reset);
/// </code>
/// </example>
/// </remarks>
public SCardError Disconnect(SCardReaderDisposition disconnectExecution)
{
ThrowOnInvalidCardHandle();
var rc = Platform.Lib.Disconnect(_cardHandle, disconnectExecution);
if (rc != SCardError.Success) {
return rc;
}
// reset local variables
_readername = null;
_cardHandle = IntPtr.Zero;
_activeprot = SCardProtocol.Unset;
_sharemode = SCardShareMode.Shared;
return rc;
}
public SCardError Disconnect(SCardReaderDisposition discntExec)
{
if (cardHandle.Equals(IntPtr.Zero))
throw new InvalidOperationException(
"Reader is currently not connected or no card handle has been returned.");
SCardError rc = SCardAPI.Lib.Disconnect(cardHandle,
discntExec);
if (rc == SCardError.Success)
{
// reset local variables
readername = null;
cardHandle = IntPtr.Zero;
activeprot = SCardProtocol.Unset;
sharemode = SCardShareMode.Shared;
}
return rc;
}
public SCardError Connect(
IntPtr hContext,
string szReader,
SCardShareMode dwShareMode,
SCardProtocol dwPreferredProtocols,
out IntPtr phCard,
out SCardProtocol pdwActiveProtocol)
{
byte[] readername = SCardHelper._ConvertToByteArray(szReader, textEncoding, SCardAPI.Lib.CharSize);
IntPtr ctx = (IntPtr)hContext;
IntPtr sharemode = (IntPtr)dwShareMode;
IntPtr prefproto = (IntPtr)dwPreferredProtocols;
IntPtr card;
IntPtr activeproto;
IntPtr result = SCardConnect(ctx,
readername,
sharemode,
prefproto,
out card,
out activeproto);
phCard = card;
pdwActiveProtocol = (SCardProtocol)activeproto;
return SCardHelper.ToSCardError(result);
}
/// <summary>Reestablishes a connection to a reader that was previously connected to using
/// <see
/// cref="M:PCSC.ISCardReader.Connect(System.String,PCSC.SCardShareMode,PCSC.SCardProtocol)" />
/// .</summary>
/// <param name="mode">Mode of connection type: exclusive/shared.
/// <list type="table">
/// <listheader>
/// <term>Value</term><description>Description</description>
/// </listheader>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardShareMode.Shared" />
/// </term>
/// <description>This application will allow others to share the reader. (SCARD_SHARE_SHARED)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardShareMode.Exclusive" />
/// </term>
/// <description>This application will NOT allow others to share the reader. (SCARD_SHARE_EXCLUSIVE)</description>
/// </item>
/// </list>
/// </param>
/// <param name="preferredProtocol">Desired protocol use.</param>
/// <param name="initialExecution">Desired action taken on the card/reader before reconnect.</param>
/// <returns>An error code / return value:
/// <list type="table">
/// <listheader>
/// <term>Error code</term><description>Description</description>
/// </listheader>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.Success" />
/// </term>
/// <description>Successful (SCARD_S_SUCCESS)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidHandle" />
/// </term>
/// <description>Invalid context handle (SCARD_E_INVALID_HANDLE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidParameter" />
/// </term>
/// <description>
/// <paramref name="preferredProtocol" /> is invalid or <see langword="null" /> (SCARD_E_INVALID_PARAMETER)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidValue" />
/// </term>
/// <description>Invalid sharing mode, requested protocol, or reader name (SCARD_E_INVALID_VALUE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoService" />
/// </term>
/// <description>The server is not runing (SCARD_E_NO_SERVICE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoSmartcard" />
/// </term>
/// <description>No smart card present (SCARD_E_NO_SMARTCARD)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NotReady" />
/// </term>
/// <description>Could not allocate the desired port (SCARD_E_NOT_READY)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.ProtocolMismatch" />
/// </term>
/// <description>Requested protocol is unknown (SCARD_E_PROTO_MISMATCH)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.ReaderUnavailable" />
/// </term>
/// <description>Could not power up the reader or card (SCARD_E_READER_UNAVAILABLE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.SharingViolation" />
/// </term>
/// <description>Someone else has exclusive rights (SCARD_E_SHARING_VIOLATION)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnsupportedFeature" />
/// </term>
/// <description>Protocol not supported (SCARD_E_UNSUPPORTED_FEATURE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.CommunicationError" />
/// </term>
/// <description>An internal communications error has been detected (SCARD_F_COMM_ERROR)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InternalError" />
/// </term>
/// <description>An internal consistency check failed (SCARD_F_INTERNAL_ERROR)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.RemovedCard" />
/// </term>
/// <description>The smart card has been removed (SCARD_W_REMOVED_CARD)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnresponsiveCard" />
/// </term>
/// <description>Card is mute (SCARD_W_UNRESPONSIVE_CARD)</description>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// <paramref name="preferredProtocol" /> is a bit mask of acceptable protocols for the connection. You can use (<see cref="F:PCSC.SCardProtocol.T0" /> | <see cref="F:PCSC.SCardProtocol.T1" />) if you do not have a preferred protocol. The protocol used with this connection will be stored in <see cref="P:PCSC.ISCardReader.ActiveProtocol" />.</para>
/// <para>This method calls the API function SCardReconnect().</para>
/// </remarks>
public SCardError Reconnect(SCardShareMode mode, SCardProtocol preferredProtocol,
SCardReaderDisposition initialExecution)
{
ThrowOnInvalidCardHandle();
SCardProtocol dwActiveProtocol;
var rc = Platform.Lib.Reconnect(_cardHandle,
mode,
preferredProtocol,
initialExecution,
out dwActiveProtocol);
if (rc != SCardError.Success) {
return rc;
}
_activeprot = dwActiveProtocol;
_sharemode = mode;
return rc;
}
public static extern PCSCResult SCardConnect(IntPtr hContext, string cReaderName,
SCardShareMode dwShareMode, SCardProtocol dwPrefProtocol, ref IntPtr phCard, ref SCardProtocol ActiveProtocol);
/// <inheritdoc />
public void Reconnect(SCardShareMode mode, SCardProtocol preferredProtocol,
SCardReaderDisposition initialExecution)
{
CardHandle.Reconnect(mode, preferredProtocol, initialExecution);
}
private static extern SCardError SCardConnect(IntPtr hContext, string szReader, SCardShareMode dwShareMode, SCardProtocol dwPreferredProtocols, [Out] out IntPtr phCard,
[Out] out SCardProtocol pdwActiveProtocol);
/// <summary>Initializes a new instance of the <see cref="IsoReader" /> class that will create its own instance of a <see cref="SCardReader" /> and immediately connect.</summary>
/// <param name="context">A context to the PC/SC Resource Manager.</param>
/// <param name="readerName">Name of the reader to connect with.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
/// <param name="releaseContextOnDispose">if set to <c>true</c> the <paramref name="context" /> will be released on <see cref="Dispose()" />.</param>
public IsoReader(ISCardContext context, string readerName, SCardShareMode mode, SCardProtocol protocol,
bool releaseContextOnDispose = true)
: this(context, releaseContextOnDispose)
{
Connect(readerName, mode, protocol);
}
/// <summary>Initializes a new instance of the <see cref="IsoReader" /> class and immediately connects to the reader.</summary>
/// <param name="reader">The supplied reader will be used for communication with the smart card.</param>
/// <param name="readerName">Name of the reader to connect with.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
/// <param name="disconnectReaderOnDispose">if set to <c>true</c> the supplied <paramref name="reader" /> will be disconnected on <see cref="Dispose()" />.</param>
public IsoReader(ISCardReader reader, string readerName, SCardShareMode mode, SCardProtocol protocol,
bool disconnectReaderOnDispose = true)
: this(reader, disconnectReaderOnDispose)
{
Connect(readerName, mode, protocol);
}
public SCardError Reconnect(
IntPtr hCard,
SCardShareMode dwShareMode,
SCardProtocol dwPreferredProtocols,
SCardReaderDisposition dwInitialization,
out SCardProtocol pdwActiveProtocol)
{
IntPtr activeproto;
IntPtr result = SCardReconnect(
(IntPtr)hCard,
(IntPtr)dwShareMode,
(IntPtr)dwPreferredProtocols,
(IntPtr)dwInitialization,
out activeproto);
pdwActiveProtocol = (SCardProtocol)activeproto;
return SCardHelper.ToSCardError(result);
}
/// <summary>Initializes a new instance of the <see cref="IsoReader" /> class that will create its own instance of a <see cref="SCardReader" /> and immediately connect.</summary>
/// <param name="context">A context to the PC/SC Resource Manager.</param>
/// <param name="readerName">Name of the reader to connect with.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
/// <param name="releaseContextOnDispose">if set to <c>true</c> the <paramref name="context" /> will be released on <see cref="Dispose()" />.</param>
public IsoReader(ISCardContext context, string readerName, SCardShareMode mode, SCardProtocol protocol,
bool releaseContextOnDispose = true)
: this(context, releaseContextOnDispose) {
Connect(readerName, mode, protocol);
}
/// <summary>Establishes a connection to the Smart Card reader.</summary>
/// <param name="readerName">Reader name to connect to.</param>
/// <param name="mode">Mode of connection type: exclusive or shared.
/// <list type="table">
/// <listheader>
/// <term>Value</term><description>Description</description>
/// </listheader>
/// <item>
/// <term><see cref="F:PCSC.SCardShareMode.Shared" /></term>
/// <description>This application will allow others to share the reader. (SCARD_SHARE_SHARED)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardShareMode.Exclusive" />
/// </term>
/// <description>This application will NOT allow others to share the reader. (SCARD_SHARE_EXCLUSIVE)</description>
/// </item>
/// </list>
/// </param>
/// <param name="preferredProtocol">Desired protocol use.</param>
/// <returns>An error code / return value:
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Error code</term><description>Description</description>
/// </listheader>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.Success" />
/// </term>
/// <description>Successful (SCARD_S_SUCCESS)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidHandle" />
/// </term>
/// <description>Invalid context handle (SCARD_E_INVALID_HANDLE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidParameter" />
/// </term>
/// <description>
/// <paramref name="preferredProtocol" /> is invalid or <see langword="null" /> (SCARD_E_INVALID_PARAMETER)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InvalidValue" />
/// </term>
/// <description>Invalid sharing mode, requested protocol, or reader name (SCARD_E_INVALID_VALUE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoService" />
/// </term>
/// <description>The server is not runing (SCARD_E_NO_SERVICE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NoSmartcard" />
/// </term>
/// <description>No smart card present (SCARD_E_NO_SMARTCARD)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.NotReady" />
/// </term>
/// <description>Could not allocate the desired port (SCARD_E_NOT_READY)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.ProtocolMismatch" />
/// </term>
/// <description>Requested protocol is unknown (SCARD_E_PROTO_MISMATCH)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.ReaderUnavailable" />
/// </term>
/// <description>Could not power up the reader or card (SCARD_E_READER_UNAVAILABLE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.SharingViolation" />
/// </term>
/// <description>Someone else has exclusive rights (SCARD_E_SHARING_VIOLATION)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnknownReader" />
/// </term>
/// <description>The reader name is <see langword="null" /> (SCARD_E_UNKNOWN_READER)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnsupportedFeature" />
/// </term>
/// <description>Protocol not supported (SCARD_E_UNSUPPORTED_FEATURE)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.CommunicationError" />
/// </term>
/// <description>An internal communications error has been detected (SCARD_F_COMM_ERROR)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.InternalError" />
/// </term>
/// <description>An internal consistency check failed (SCARD_F_INTERNAL_ERROR)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnpoweredCard" />
/// </term>
/// <description>Card is not powered (SCARD_W_UNPOWERED_CARD)</description>
/// </item>
/// <item>
/// <term>
/// <see cref="F:PCSC.SCardError.UnresponsiveCard" />
/// </term>
/// <description>Card is mute (SCARD_W_UNRESPONSIVE_CARD)</description>
/// </item>
/// </list>
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// <paramref name="preferredProtocol" /> is a bit mask of acceptable protocols for the connection. You can use (<see cref="F:PCSC.SCardProtocol.T0" /> | <see cref="F:PCSC.SCardProtocol.T1" />) if you do not have a preferred protocol. The protocol used with this connection will be stored in <see cref="P:PCSC.ISCardReader.ActiveProtocol" />.</para>
/// <para>This method calls the API function SCardConnect().</para>
/// <example>
/// <code lang="C#">
/// // Establish PC/SC context.
/// SCardContext ctx = new SCardContext();
/// ctx.Establish(SCardScope.System);
///
/// // Create a Smart Card reader object and connect to it.
/// ISCardReader reader = new SCardReader(ctx);
/// SCardError serr = reader.Connect("OMNIKEY CardMan 5x21 00 00",
/// SCardShareMode.Shared,
/// SCardProtocol.Any);
/// </code>
/// </example>
/// </remarks>
public SCardError Connect(string readerName, SCardShareMode mode, SCardProtocol preferredProtocol)
{
if (readerName == null) {
throw new ArgumentNullException("readerName");
}
if (readerName.IsNullOrWhiteSpace()) {
throw new UnknownReaderException(SCardError.InvalidValue, "Invalid card reader name.");
}
if (_context == null || _context.Handle.Equals(IntPtr.Zero)) {
throw new InvalidContextException(SCardError.InvalidHandle, "Invalid connection context.");
}
IntPtr hCard;
SCardProtocol dwActiveProtocol;
var rc = Platform.Lib.Connect(_context.Handle,
readerName,
mode,
preferredProtocol,
out hCard,
out dwActiveProtocol);
if (rc != SCardError.Success) {
return rc;
}
_cardHandle = hCard;
_activeprot = dwActiveProtocol;
_readername = readerName;
_sharemode = mode;
return rc;
}
/// <summary>Connects the specified reader.</summary>
/// <param name="readerName">Name of the reader.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
public virtual void Connect(string readerName, SCardShareMode mode, SCardProtocol protocol) {
if (readerName == null) {
throw new ArgumentNullException("readerName");
}
if (protocol == SCardProtocol.Unset) {
throw new InvalidProtocolException(SCardError.InvalidValue);
}
if (((long) mode) == 0) {
throw new InvalidShareModeException(SCardError.InvalidValue);
}
var sc = _reader.Connect(readerName, mode, protocol);
// Throws an exception if sc != SCardError.Success
sc.ThrowIfNotSuccess();
}
public SCardError Connect(string name,
SCardShareMode mode,
SCardProtocol prefProto)
{
if (name == null ||
name.Equals(""))
throw new UnknownReaderException(SCardError.InvalidValue, "Invalid card reader name.");
if (context == null || context.contextPtr.Equals(IntPtr.Zero))
throw new InvalidContextException(SCardError.InvalidHandle, "Invalid connection context.");
SCardError rc;
IntPtr hCard = IntPtr.Zero;
SCardProtocol dwActiveProtocol;
rc = SCardAPI.Lib.Connect(context.contextPtr,
name,
mode,
prefProto,
out hCard,
out dwActiveProtocol);
if (rc == SCardError.Success)
{
cardHandle = hCard;
activeprot = dwActiveProtocol;
readername = name;
sharemode = mode;
}
return rc;
}
/// <summary>Initializes a new instance of the <see cref="IsoReader" /> class and immediately connects to the reader.</summary>
/// <param name="reader">The supplied reader will be used for communication with the smart card.</param>
/// <param name="readerName">Name of the reader to connect with.</param>
/// <param name="mode">The share mode.</param>
/// <param name="protocol">The communication protocol. <seealso cref="ISCardReader.Connect(string,SCardShareMode,SCardProtocol)" /></param>
/// <param name="disconnectReaderOnDispose">if set to <c>true</c> the supplied <paramref name="reader" /> will be disconnected on <see cref="Dispose()" />.</param>
public IsoReader(ISCardReader reader, string readerName, SCardShareMode mode, SCardProtocol protocol,
bool disconnectReaderOnDispose = true)
: this(reader, disconnectReaderOnDispose) {
Connect(readerName, mode, protocol);
}
public SCardError Reconnect(SCardShareMode mode,
SCardProtocol prefProto,
SCardReaderDisposition initExec)
{
if (cardHandle.Equals(IntPtr.Zero))
throw new InvalidOperationException(
"Reader is currently not connected or no card handle has been returned.");
SCardProtocol dwActiveProtocol = activeprot;
SCardError rc = SCardAPI.Lib.Reconnect(cardHandle,
mode,
prefProto,
initExec,
out dwActiveProtocol);
if (rc == SCardError.Success)
{
activeprot = dwActiveProtocol;
sharemode = mode;
}
return rc;
}
private static extern SCardError SCardReconnect(IntPtr hCard, SCardShareMode dwShareMode, SCardProtocol dwPreferredProtocols, SCardDisposition dwDisposition, [Out] out SCardProtocol pdwActiveProtocol);
