/usr/include/smartcardpp/ManagerInterface.h is in libsmartcardpp-dev 0.3.0-0ubuntu7.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | /*
* SMARTCARDPP
*
* This software is released under either the GNU Library General Public
* License (see LICENSE.LGPL) or the BSD License (see LICENSE.BSD).
*
* Note that the only valid version of the LGPL license as far as this
* project is concerned is the original GNU Library General Public License
* Version 2.1, February 1999
*
*/
#pragma once
#include "types.h"
#include <stdexcept>
struct ConnectionBase;
struct PCSCConnection;
/// Abstraction of the system smartcard manager
class ManagerInterface
{
private: //disable object copying
ManagerInterface(const ManagerInterface &);
ManagerInterface& operator=(const ManagerInterface &);
public:
ManagerInterface(void): mLogger(NULL) {}
virtual ~ManagerInterface(void) {}
/// number of installed readers
virtual uint getReaderCount(bool forceRefresh=true) = 0;
/// name of the reader at index
virtual std::string getReaderName(uint index) = 0;
/// string form of reader status at index, EMPTY, POWERED etc
virtual std::string getReaderState(uint index) = 0;
/// hex representation of card ATR in reader at index, empty string if no card is present
virtual std::string getATRHex(uint index) = 0;
virtual std::string getATRHex(ConnectionBase* conn) = 0;
// checks if reader has pinpad features
virtual bool isPinPad(uint index,PCSCConnection *c=0) = 0;
/// connects instance of card to reader at index, forceT0 is used for cards that cant speak T1
virtual ConnectionBase * connect(uint index) = 0;
/// reconnect using a different protocol
virtual ConnectionBase * reconnect(ConnectionBase *c) = 0;
/// use given stream as APDU log
inline void setLogging(std::ostream *logStream) {mLogger = logStream;}
virtual void beginTransaction(ConnectionBase *c) = 0;
virtual void endTransaction(ConnectionBase *c,bool forceReset = false) = 0;
virtual void writeLog(const char *fmt,...) = 0;
protected:
std::ostream *mLogger;
friend struct ConnectionBase;
friend struct Transaction;
friend class CardBase;
friend class SmartCardManager;
friend struct SmartCardConnection;
virtual void makeConnection(ConnectionBase *c,uint idx) = 0;
virtual void deleteConnection(ConnectionBase *c) = 0;
virtual void execCommand(ConnectionBase *c,std::vector<byte> &cmd,std::vector<byte> &recv,
unsigned int &recvLen) = 0;
virtual void execPinEntryCommand(ConnectionBase *c,std::vector<byte> &cmd) {
UNUSED_ARG(c);UNUSED_ARG(cmd);
throw std::runtime_error("This manager does not support PIN entry commands");
}
virtual void execPinChangeCommand(ConnectionBase *c,std::vector<byte> &cmd
,size_t oldPinLen,size_t newPinLen) {
UNUSED_ARG(c);UNUSED_ARG(cmd);
UNUSED_ARG(oldPinLen);UNUSED_ARG(newPinLen);
throw std::runtime_error("This manager does not support PIN change commands");
}
/// tell if given connection is using T1 (true) or T0
virtual bool isT1Protocol(ConnectionBase *c) = 0;
};
/// Represents connection to smart card reader
/** ConnectionBase represents a connection of a smart card instance to reader,
and holds the connection parameters.
Concrete derivations are PCSCConnection and CTAPIConnection */
struct ConnectionBase {
/// reference to Manager
ManagerInterface &mManager;
/// reader index
uint mIndex;
/// if false, we are using application-supplied connection handle
bool mOwnConnection;
/// tells if the manager has a secure PIN input method, true for CTAPI
virtual bool isSecure() {return false;}
ConnectionBase(ManagerInterface &manager) :
mManager(manager),mIndex((uint)-1),mOwnConnection(false) {}
ConnectionBase(ManagerInterface &manager,unsigned int index)
: mManager(manager),mIndex(index),mOwnConnection(true) {
mManager.makeConnection(this,index);
}
virtual ~ConnectionBase() {
if (mOwnConnection)
mManager.deleteConnection(this);
}
private:
const ConnectionBase operator=(const ConnectionBase &);
};
/// Wraps a beginTransaction/endTransaction pair
/** Transaction wraps a beginTransaction/endTransaction pair, so functions can be performed
on cards without interruptions. It needs to be instanced from a given smart card function
that needs to be performed as an atomic unit */
struct Transaction {
ManagerInterface& mManager;
ConnectionBase *mConnection;
Transaction(ManagerInterface& manager,ConnectionBase *connection): mManager(manager),mConnection(connection) {
mManager.beginTransaction(mConnection);
}
~Transaction() {
mManager.endTransaction(mConnection);
}
private:
const Transaction operator=(const Transaction &);
};
|