// CkSCardW.h: interface for the CkSCardW class. // ////////////////////////////////////////////////////////////////////// // This header is generated for Chilkat 11.3.0 #ifndef _CkSCardW_H #define _CkSCardW_H #include "chilkatDefs.h" #include "CkString.h" #include "CkClassWithCallbacksW.h" class CkJsonObjectW; class CkBinDataW; class CkStringTableW; class CkTaskW; class CkBaseProgressW; #if !defined(__sun__) && !defined(__sun) #pragma pack (push, 8) #endif // CLASS: CkSCardW class CK_VISIBLE_PUBLIC CkSCardW : public CkClassWithCallbacksW { private: bool m_cbOwned; private: // Don't allow assignment or copying these objects. CkSCardW(const CkSCardW &); CkSCardW &operator=(const CkSCardW &); public: CkSCardW(void); virtual ~CkSCardW(void); static CkSCardW *createNew(void); CkSCardW(bool bCallbackOwned); static CkSCardW *createNew(bool bCallbackOwned); void CK_VISIBLE_PRIVATE inject(void *impl); // May be called when finished with the object to free/dispose of any // internal resources held by the object. void dispose(void); CkBaseProgressW *get_EventCallbackObject(void) const; void put_EventCallbackObject(CkBaseProgressW *progress); // BEGIN PUBLIC INTERFACE // ---------------------- // Properties // ---------------------- // The name of the active protocol if connected smart card reader, or an empty // string if not connected. Possible values are T0 , T1 , raw , undefined , or if // not connected to a reader. void get_ActiveProtocol(CkString &str); // The name of the active protocol if connected smart card reader, or an empty // string if not connected. Possible values are T0 , T1 , raw , undefined , or if // not connected to a reader. const wchar_t *activeProtocol(void); // This is the Current ATR of a card in the connected reader. void get_CardAtr(CkString &str); // This is the Current ATR of a card in the connected reader. const wchar_t *cardAtr(void); // The name of the currently connected smart card reader, or an empty string if not // connected. void get_ConnectedReader(CkString &str); // The name of the currently connected smart card reader, or an empty string if not // connected. const wchar_t *connectedReader(void); // Contains the string user or system if this object has established a context (by // calling EstablishContext). Contains the empty string if no context is // established. void get_Context(CkString &str); // Contains the string user or system if this object has established a context (by // calling EstablishContext). Contains the empty string if no context is // established. const wchar_t *context(void); // For Linux systems only. Specifies the full path of the libpcsclite.so shared // lib. This property should only be used if the libpcsclite.so is in a // non-standard location or if Chilkat cannot automatically located it. void get_PcscLibPath(CkString &str); // For Linux systems only. Specifies the full path of the libpcsclite.so shared // lib. This property should only be used if the libpcsclite.so is in a // non-standard location or if Chilkat cannot automatically located it. const wchar_t *pcscLibPath(void); // For Linux systems only. Specifies the full path of the libpcsclite.so shared // lib. This property should only be used if the libpcsclite.so is in a // non-standard location or if Chilkat cannot automatically located it. void put_PcscLibPath(const wchar_t *newVal); // The current status of the connected reader. Possible values are: // * absent - There is no card in the reader. // * present - There is a card in the reader, but it has not been moved into // position for use. // * swallowed - There is a card in the reader in position for use. The card is // not powered. // * powered - Power is being provided to the card, but the reader driver is // unaware of the mode of the card. // * negotiable - The card has been reset and is awaiting PTS negotiation. // * specific - The card has been reset and specific communication protocols // have been established. void get_ReaderStatus(CkString &str); // The current status of the connected reader. Possible values are: // * absent - There is no card in the reader. // * present - There is a card in the reader, but it has not been moved into // position for use. // * swallowed - There is a card in the reader in position for use. The card is // not powered. // * powered - Power is being provided to the card, but the reader driver is // unaware of the mode of the card. // * negotiable - The card has been reset and is awaiting PTS negotiation. // * specific - The card has been reset and specific communication protocols // have been established. const wchar_t *readerStatus(void); // The last error returned by an underlying PC/SC function. Can be one of the // following: // * SCARDWREMOVED_CARD - The smart card has been removed, so that further // communication is not possible. // * SCARDWRESET_CARD - The smart card has been reset, so any shared state // information is invalid. // * ... void get_ScardError(CkString &str); // The last error returned by an underlying PC/SC function. Can be one of the // following: // * SCARDWREMOVED_CARD - The smart card has been removed, so that further // communication is not possible. // * SCARDWRESET_CARD - The smart card has been reset, so any shared state // information is invalid. // * ... const wchar_t *scardError(void); // ---------------------- // Methods // ---------------------- // Establishes a temporary exclusive access mode for doing a series of commands in // a transaction. bool BeginTransaction(void); // Check the current status of the currently connected reader. Calling this method // updates the ReaderStatus, ActiveProtocol, and CardAtr properties. If this method // returns false, none of the properties are updated. bool CheckStatus(void); // Establish a connection to a reader. The reader is the name of a reader returned // from ListReaders. The shareMode can be shared , exclusive , or direct . The preferredProtocol can // be 0 (valid only if the shareMode = direct ), T0 , T1 , raw , or no_preference . // (No preference is effectively T0 or T1.) // // If successful, the state of this object instance is that it's connected to the // reader. // bool Connect(const wchar_t *reader, const wchar_t *shareMode, const wchar_t *preferredProtocol); // Terminates a connection with a reader. The disposition can be one of the following // values: // * leave : Do nothing. // * reset : Reset the card (warm reset). // * unpower : Power down the card (cold reset). // * eject : Eject the card. bool Disconnect(const wchar_t *disposition); // Ends a previously begun transaction. The disposition is the action to be taken on the // reader, and can be leave which is to do nothing, reset , unpower , or eject . bool EndTransaction(const wchar_t *disposition); // Creates an Application Context to the PC/SC Resource Manager. This must be the // first WinSCard function called in a PC/SC application. The scope can be user or // system . After calling, this object will have context and all other methods will // use the established context. The Context property will hold the value user or // system if context was established, or will be empty if no context was // established. bool EstablishContext(const wchar_t *scope); // Returns JSON containing information about the smartcards currently inserted into // readers. bool FindSmartcards(CkJsonObjectW &json); // Get an attribute from the IFD Handler (reader driver). // // The attr can be one of the following: // * ASYNC_PROTOCOL_TYPES // * ATR_STRING // * CHANNEL_ID // * CHARACTERISTICS // * CURRENT_BWT // * CURRENT_CLK // * CURRENT_CWT // * CURRENT_D // * CURRENT_EBC_ENCODING // * CURRENT_F // * CURRENT_IFSC // * CURRENT_IFSD // * CURRENT_IO_STATE // * CURRENT_N // * CURRENT_PROTOCOL_TYPE // * CURRENT_W // * DEFAULT_CLK // * DEFAULT_DATA_RATE // * DEVICE_FRIENDLY_NAME // * DEVICE_IN_USE // * DEVICE_SYSTEM_NAME // * DEVICE_UNIT // * ESC_AUTHREQUEST // * ESC_CANCEL // * ESC_RESET // * EXTENDED_BWT // * ICC_INTERFACE_STATUS // * ICC_PRESENCE // * ICC_TYPE_PER_ATR // * MAX_CLK // * MAX_DATA_RATE // * MAX_IFSD // * MAXINPUT // * POWER_MGMT_SUPPORT // * SUPRESS_T1_IFS_REQUEST // * SYNC_PROTOCOL_TYPES // * USER_AUTH_INPUT_DEVICE // * USER_TO_CARD_AUTH_DEVICE // * VENDOR_IFD_SERIAL_NO // * VENDOR_IFD_TYPE // * VENDOR_IFD_VERSION // * VENDOR_NAME // // The attribute data is returned in bd. // bool GetAttrib(const wchar_t *attr, CkBinDataW &bd); // Get a string typed attribute from the IFD Handler (reader driver). // // The attr can be one of the following, but should be limited to the particular // attributes that return string values. // * ASYNC_PROTOCOL_TYPES // * ATR_STRING // * CHANNEL_ID // * CHARACTERISTICS // * CURRENT_BWT // * CURRENT_CLK // * CURRENT_CWT // * CURRENT_D // * CURRENT_EBC_ENCODING // * CURRENT_F // * CURRENT_IFSC // * CURRENT_IFSD // * CURRENT_IO_STATE // * CURRENT_N // * CURRENT_PROTOCOL_TYPE // * CURRENT_W // * DEFAULT_CLK // * DEFAULT_DATA_RATE // * DEVICE_FRIENDLY_NAME // * DEVICE_IN_USE // * DEVICE_SYSTEM_NAME // * DEVICE_UNIT // * ESC_AUTHREQUEST // * ESC_CANCEL // * ESC_RESET // * EXTENDED_BWT // * ICC_INTERFACE_STATUS // * ICC_PRESENCE // * ICC_TYPE_PER_ATR // * MAX_CLK // * MAX_DATA_RATE // * MAX_IFSD // * MAXINPUT // * POWER_MGMT_SUPPORT // * SUPRESS_T1_IFS_REQUEST // * SYNC_PROTOCOL_TYPES // * USER_AUTH_INPUT_DEVICE // * USER_TO_CARD_AUTH_DEVICE // * VENDOR_IFD_SERIAL_NO // * VENDOR_IFD_TYPE // * VENDOR_IFD_VERSION // * VENDOR_NAME // bool GetAttribStr(const wchar_t *attr, CkString &outStr); // Get a string typed attribute from the IFD Handler (reader driver). // // The attr can be one of the following, but should be limited to the particular // attributes that return string values. // * ASYNC_PROTOCOL_TYPES // * ATR_STRING // * CHANNEL_ID // * CHARACTERISTICS // * CURRENT_BWT // * CURRENT_CLK // * CURRENT_CWT // * CURRENT_D // * CURRENT_EBC_ENCODING // * CURRENT_F // * CURRENT_IFSC // * CURRENT_IFSD // * CURRENT_IO_STATE // * CURRENT_N // * CURRENT_PROTOCOL_TYPE // * CURRENT_W // * DEFAULT_CLK // * DEFAULT_DATA_RATE // * DEVICE_FRIENDLY_NAME // * DEVICE_IN_USE // * DEVICE_SYSTEM_NAME // * DEVICE_UNIT // * ESC_AUTHREQUEST // * ESC_CANCEL // * ESC_RESET // * EXTENDED_BWT // * ICC_INTERFACE_STATUS // * ICC_PRESENCE // * ICC_TYPE_PER_ATR // * MAX_CLK // * MAX_DATA_RATE // * MAX_IFSD // * MAXINPUT // * POWER_MGMT_SUPPORT // * SUPRESS_T1_IFS_REQUEST // * SYNC_PROTOCOL_TYPES // * USER_AUTH_INPUT_DEVICE // * USER_TO_CARD_AUTH_DEVICE // * VENDOR_IFD_SERIAL_NO // * VENDOR_IFD_TYPE // * VENDOR_IFD_VERSION // * VENDOR_NAME // const wchar_t *getAttribStr(const wchar_t *attr); // Get a string typed attribute from the IFD Handler (reader driver). // // The attr can be one of the following, but should be limited to the particular // attributes that return string values. // * ASYNC_PROTOCOL_TYPES // * ATR_STRING // * CHANNEL_ID // * CHARACTERISTICS // * CURRENT_BWT // * CURRENT_CLK // * CURRENT_CWT // * CURRENT_D // * CURRENT_EBC_ENCODING // * CURRENT_F // * CURRENT_IFSC // * CURRENT_IFSD // * CURRENT_IO_STATE // * CURRENT_N // * CURRENT_PROTOCOL_TYPE // * CURRENT_W // * DEFAULT_CLK // * DEFAULT_DATA_RATE // * DEVICE_FRIENDLY_NAME // * DEVICE_IN_USE // * DEVICE_SYSTEM_NAME // * DEVICE_UNIT // * ESC_AUTHREQUEST // * ESC_CANCEL // * ESC_RESET // * EXTENDED_BWT // * ICC_INTERFACE_STATUS // * ICC_PRESENCE // * ICC_TYPE_PER_ATR // * MAX_CLK // * MAX_DATA_RATE // * MAX_IFSD // * MAXINPUT // * POWER_MGMT_SUPPORT // * SUPRESS_T1_IFS_REQUEST // * SYNC_PROTOCOL_TYPES // * USER_AUTH_INPUT_DEVICE // * USER_TO_CARD_AUTH_DEVICE // * VENDOR_IFD_SERIAL_NO // * VENDOR_IFD_TYPE // * VENDOR_IFD_VERSION // * VENDOR_NAME // const wchar_t *attribStr(const wchar_t *attr); // Get an unsigned integer typed attribute from the IFD Handler (reader driver). // // The attr can be one of the following, but should be limited to the particular // attributes that return unsigned integer values. // * ASYNC_PROTOCOL_TYPES // * ATR_STRING // * CHANNEL_ID // * CHARACTERISTICS // * CURRENT_BWT // * CURRENT_CLK // * CURRENT_CWT // * CURRENT_D // * CURRENT_EBC_ENCODING // * CURRENT_F // * CURRENT_IFSC // * CURRENT_IFSD // * CURRENT_IO_STATE // * CURRENT_N // * CURRENT_PROTOCOL_TYPE // * CURRENT_W // * DEFAULT_CLK // * DEFAULT_DATA_RATE // * DEVICE_FRIENDLY_NAME // * DEVICE_IN_USE // * DEVICE_SYSTEM_NAME // * DEVICE_UNIT // * ESC_AUTHREQUEST // * ESC_CANCEL // * ESC_RESET // * EXTENDED_BWT // * ICC_INTERFACE_STATUS // * ICC_PRESENCE // * ICC_TYPE_PER_ATR // * MAX_CLK // * MAX_DATA_RATE // * MAX_IFSD // * MAXINPUT // * POWER_MGMT_SUPPORT // * SUPRESS_T1_IFS_REQUEST // * SYNC_PROTOCOL_TYPES // * USER_AUTH_INPUT_DEVICE // * USER_TO_CARD_AUTH_DEVICE // * VENDOR_IFD_SERIAL_NO // * VENDOR_IFD_TYPE // * VENDOR_IFD_VERSION // * VENDOR_NAME // // Returns 0xFFFFFFFF on failure. // unsigned long GetAttribUint(const wchar_t *attr); // Blocks execution until the current availability of the cards in a specific set // of readers changes. // // This function receives a list of reader names in stReaderNames. It then blocks waiting // for a change in state to occur for a maximum blocking time of maxWaitMs (in // milliseconds) or forever if 0 is used. // // Information about the current reader states and which reader(s) changed is // returned in json. See the example below for more information. // // To wait for a reader event (reader added or removed) you may use the special // reader name \\?PnP?\Notification . // // To cancel the ongoing call, call Cancel(). // // The stReaderNames contains the reader names to check. The json is empty on input, and if // the call returns success contains information about the state (after the event // change) of each reader. // bool GetStatusChange(int maxWaitMs, CkStringTableW &stReaderNames, CkJsonObjectW &json); // Creates an asynchronous task to call the GetStatusChange method with the // arguments provided. // The caller is responsible for deleting the object returned by this method. CkTaskW *GetStatusChangeAsync(int maxWaitMs, CkStringTableW &stReaderNames, CkJsonObjectW &json); // Cancels an ongoing GetStatusChange method call. This would be called from a // separate thread in your application if GetStatusChange was called synchronously. bool GetStatusChangeCancel(void); // Returns a list of currently available reader groups on the system. The reader // groups are returned in readerGroups. bool ListReaderGroups(CkStringTableW &readerGroups); // Returns a list of currently available readers on the system. bool ListReaders(CkStringTableW &st); // Reestablishes a connection to a reader that was previously connected to using // Connect(). // // In a multi application environment it is possible for an application to reset // the card in shared mode. When this occurs any other application trying to access // certain commands will be returned the value SCARDWRESET_CARD. When this occurs // Reconnect() must be called in order to acknowledge that the card was reset and // allow it to change its state accordingly. // // The shareMode can be shared , exclusive , or direct . The preferredProtocol can be 0 (valid only // if the shareMode = direct ), T0 , T1 , raw , or no_preference . (No preference // is effectively T0 or T1.) The action is the desired action taken on the // card/reader. It can be leave , reset , unpower , or eject . // // If successful, the state of this object instance is that it's connected to the // reader. // bool Reconnect(const wchar_t *shareMode, const wchar_t *preferredProtocol, const wchar_t *action); // Destroys a communication context to the PC/SC Resource Manager. This must be the // last function called in a PC/SC application. bool ReleaseContext(void); // Sends a command directly to the IFD Handler (reader driver) to be processed by // the reader. // // This is useful for creating client side reader drivers for functions like PIN // pads, biometrics, or other extensions to the normal smart card reader that are // not normally handled by PC/SC. // // The command data is sent in bdSend. The response is written to bdRecv. // bool SendControl(unsigned long controlCode, CkBinDataW &bdSend, CkBinDataW &bdRecv); // Sends a command directly to the IFD Handler (reader driver) to be processed by // the reader. // // This is useful for creating client side reader drivers for functions like PIN // pads, biometrics, or other extensions to the normal smart card reader that are // not normally handled by PC/SC. // // The command data is provided as a hex string in sendData. The response is written to // bdRecv. // bool SendControlHex(unsigned long controlCode, const wchar_t *sendData, CkBinDataW &bdRecv); // Sends an APDU to the smart card contained in the currently connected reader. The // protocol can be T0 , T1 , or raw . The APDU to be sent is contained in bdSend. The // response from the card is contained in bdRecv. The maxRecvLen is the maximum response // size (in bytes) willing to be accepted. bool Transmit(const wchar_t *protocol, CkBinDataW &bdSend, CkBinDataW &bdRecv, int maxRecvLen); // Sends an APDU to the smart card contained in the currently connected reader. The // protocol can be T0 , T1 , or raw . The APDU (in hexadecimal) to be sent is passed in // apduHex. The response from the card is contained in bdRecv. The maxRecvLen is the maximum // response size (in bytes) willing to be accepted. bool TransmitHex(const wchar_t *protocol, const wchar_t *apduHex, CkBinDataW &bdRecv, int maxRecvLen); // END PUBLIC INTERFACE }; #if !defined(__sun__) && !defined(__sun) #pragma pack (pop) #endif #endif