CardTransactionManagerAdapter.h

Go to the documentation of this file.

/**************************************************************************************************
 * Copyright (c) 2021 Calypso Networks Association https://calypsonet.org/                        *
 *                                                                                                *
 * See the NOTICE file(s) distributed with this work for additional information regarding         *
 * copyright ownership.                                                                           *
 *                                                                                                *
 * This program and the accompanying materials are made available under the terms of the Eclipse  *
 * Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0                  *
 *                                                                                                *
 * SPDX-License-Identifier: EPL-2.0                                                               *
 **************************************************************************************************/
 
#pragma once
 
#include <atomic>
#include <memory>
#include <ostream>
 
/* Calypsonet Terminal Calypso */
#include "CardSecuritySetting.h"
#include "CardTransactionManager.h"
#include "SearchCommandData.h"
#include "SvAction.h"
#include "WriteAccessLevel.h"
 
/* Calypsonet Terminal Card */
#include "ApduResponseApi.h"
#include "ChannelControl.h"
#include "ProxyReaderApi.h"
 
/* Keyple Card Calypso */
#include "CalypsoCardAdapter.h"
#include "CardCommandManager.h"
#include "SamCommandProcessor.h"
 
/* Keyple Core Util */
#include "LoggerFactory.h"
 
namespace keyple {
namespace card {
namespace calypso {
 
using namespace calypsonet::terminal::calypso;
using namespace calypsonet::terminal::calypso::transaction;
using namespace calypsonet::terminal::card;
using namespace keyple::core::util::cpp;
 
class CardTransactionManagerAdapter final : public CardTransactionManager {
public:
    enum class SessionState {
        SESSION_UNINITIALIZED,
 
        SESSION_OPEN,
 
        SESSION_CLOSED
    };
 
    CardTransactionManagerAdapter(const std::shared_ptr<CardReader> cardReader,
                                  const std::shared_ptr<CalypsoCard> calypsoCard,
                                  const std::shared_ptr<CardSecuritySetting> cardSecuritySetting);
 
    CardTransactionManagerAdapter(const std::shared_ptr<CardReader> cardReader,
                                  const std::shared_ptr<CalypsoCard> calypsoCard);
 
    const std::shared_ptr<CardReader> getCardReader() const override;
 
    const std::shared_ptr<CalypsoCard> getCalypsoCard() const override;
 
    const std::shared_ptr<CardSecuritySetting> getCardSecuritySetting() const override;
 
    const std::string getTransactionAuditData() const override;
 
    CardTransactionManager& processOpening(const WriteAccessLevel writeAccessLevel) final;
 
    CardTransactionManager& processCardCommands() final;
 
    CardTransactionManager& processClosing() final;
 
    CardTransactionManager& processCancel() final;
 
    CardTransactionManager& processVerifyPin(const std::vector<uint8_t>& pin) final;
    CardTransactionManager& processChangePin(const std::vector<uint8_t>& newPin) override;
 
    CardTransactionManager& processChangeKey(const uint8_t keyIndex,
                                             const uint8_t newKif,
                                             const uint8_t newKvc,
                                             const uint8_t issuerKif,
                                             const uint8_t issuerKvc) override;
 
    CardTransactionManager& prepareReleaseCardChannel() final;
 
    CardTransactionManager& prepareSelectFile(const std::vector<uint8_t>& lid) final;
 
    CardTransactionManager& prepareSelectFile(const uint16_t lid) override;
 
    CardTransactionManager& prepareSelectFile(const SelectFileControl selectFileControl) final;
 
    CardTransactionManager& prepareGetData(const GetDataTag tag) override;
 
    CardTransactionManager& prepareReadRecordFile(const uint8_t sfi, const uint8_t recordNumber) 
        final;
 
    CardTransactionManager& prepareReadRecordFile(const uint8_t sfi,
                                                  const uint8_t firstRecordNumber,
                                                  const uint8_t numberOfRecords,
                                                  const uint8_t recordSize) final;
 
    CardTransactionManager& prepareReadCounterFile(const uint8_t sfi, const uint8_t countersNumber)
        final;
 
    CardTransactionManager& prepareReadRecord(const uint8_t sfi, const uint8_t recordNumber) 
        override;
 
    CardTransactionManager& prepareReadRecords(const uint8_t sfi,
                                               const uint8_t fromRecordNumber,
                                               const uint8_t toRecordNumber,
                                               const uint8_t recordSize) override;
 
    CardTransactionManager& prepareReadRecordsPartially(const uint8_t sfi,
                                                        const uint8_t fromRecordNumber,
                                                        const uint8_t toRecordNumber,
                                                        const uint8_t offset,
                                                        const uint8_t nbBytesToRead) override;
 
    CardTransactionManager& prepareReadBinary(const uint8_t sfi,
                                              const uint8_t offset,
                                              const uint8_t nbBytesToRead) override;
 
    CardTransactionManager& prepareReadCounter(const uint8_t sfi, const uint8_t nbCountersToRead)
        override;
 
    CardTransactionManager& prepareSearchRecords(const std::shared_ptr<SearchCommandData> data)
        override;
 
    CardTransactionManager& prepareAppendRecord(const uint8_t sfi,
                                                const std::vector<uint8_t>& recordData) final;
 
    CardTransactionManager& prepareUpdateRecord(const uint8_t sfi,
                                                const uint8_t recordNumber,
                                                const std::vector<uint8_t>& recordData) final;
 
    CardTransactionManager& prepareWriteRecord(const uint8_t sfi,
                                               const uint8_t recordNumber,
                                               const std::vector<uint8_t>& recordData) final;
 
    CardTransactionManager& prepareUpdateBinary(const uint8_t sfi,
                                                const uint8_t offset,
                                                const std::vector<uint8_t>& data) final;
 
    CardTransactionManager& prepareWriteBinary(const uint8_t sfi,
                                               const uint8_t offset,
                                               const std::vector<uint8_t>& data) final;
 
    CardTransactionManager& prepareIncreaseCounter(const uint8_t sfi,
                                                   const uint8_t counterNumber,
                                                   const int incValue) final;
 
    CardTransactionManager& prepareDecreaseCounter(const uint8_t sfi,
                                                   const uint8_t counterNumber,
                                                   const int decValue) final;
 
    CardTransactionManager& prepareDecreaseCounters(
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToDecValueMap) final;
 
    CardTransactionManager& prepareIncreaseCounters(
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToIncValueMap) final;
 
    CardTransactionManager& prepareSetCounter(const uint8_t sfi,
                                              const uint8_t counterNumber,
                                              const int newValue) final;
 
    CardTransactionManager& prepareCheckPinStatus() final;
 
    CardTransactionManager& prepareSvGet(const SvOperation svOperation, const SvAction svAction)
        final;
 
    CardTransactionManager& prepareSvReload(const int amount,
                                            const std::vector<uint8_t>& date,
                                            const std::vector<uint8_t>& time,
                                            const std::vector<uint8_t>& free) final;
 
    CardTransactionManager& prepareSvReload(const int amount) final;
 
    CardTransactionManager& prepareSvDebit(const int amount,
                                           const std::vector<uint8_t>& date,
                                           const std::vector<uint8_t>& time) final;
 
    CardTransactionManager& prepareSvDebit(const int amount) final;
 
    CardTransactionManager& prepareSvReadAllLogs() final;
 
    CardTransactionManager& prepareInvalidate() final;
 
    CardTransactionManager& prepareRehabilitate() final;
 
    friend std::ostream& operator<<(std::ostream& os, const SessionState ss);
 
 
private:
    class ApduResponseAdapter final : public ApduResponseApi {
    public:
        friend class CardTransactionManagerAdapter;
 
        ApduResponseAdapter(const std::vector<uint8_t>& apdu);
 
        const std::vector<uint8_t>& getApdu() const override;
 
        const std::vector<uint8_t> getDataOut() const override;
 
        int getStatusWord() const override;
 
    private:
        const std::vector<uint8_t> mApdu;
 
        const int mStatusWord;
    };
 
    const std::unique_ptr<Logger> mLogger =
        LoggerFactory::getLogger(typeid(CardTransactionManagerAdapter));
 
    static const std::string CARD_READER_COMMUNICATION_ERROR;
    static const std::string CARD_COMMUNICATION_ERROR;
    static const std::string CARD_COMMAND_ERROR;
    static const std::string SAM_READER_COMMUNICATION_ERROR ;
    static const std::string SAM_COMMUNICATION_ERROR;
    static const std::string SAM_COMMAND_ERROR;
    static const std::string PIN_NOT_AVAILABLE_ERROR;
    static const std::string GENERATING_OF_THE_PIN_CIPHERED_DATA_ERROR;
    static const std::string GENERATING_OF_THE_KEY_CIPHERED_DATA_ERROR;
    static const std::string TRANSMITTING_COMMANDS;
    static const std::string CHECKING_THE_SV_OPERATION;
    static const std::string UNEXPECTED_EXCEPTION;
    static const std::string RECORD_NUMBER;
 
    static const int SESSION_BUFFER_CMD_ADDITIONAL_COST;
    static const int APDU_HEADER_LENGTH;
 
    static const std::string OFFSET;
 
    const std::shared_ptr<ProxyReaderApi> mCardReader;
 
    const std::shared_ptr<CardSecuritySetting> mCardSecuritySettings;
 
    std::shared_ptr<SamCommandProcessor> mSamCommandProcessor;
 
    const std::shared_ptr<CalypsoCardAdapter> mCalypsoCard;
 
    SessionState mSessionState;
 
    WriteAccessLevel mCurrentWriteAccessLevel;
 
    int mModificationsCounter;
 
    std::shared_ptr<CardCommandManager> mCardCommandManager;
 
    SvAction mSvAction;
 
    ChannelControl mChannelControl;
 
    static const std::shared_ptr<ApduResponseApi> RESPONSE_OK;
    static const std::shared_ptr<ApduResponseApi> RESPONSE_OK_POSTPONED;
 
    const std::vector<std::shared_ptr<ApduRequestSpi>> getApduRequests(
        const std::vector<std::shared_ptr<AbstractCardCommand>>& cardCommands);
 
    void processAtomicCardCommands(
        const std::vector<std::shared_ptr<AbstractCardCommand>> cardCommands,
        const ChannelControl channelControl);
 
    void processAtomicClosing(
        const std::vector<std::shared_ptr<AbstractCardCommand>>& cardModificationCommands,
        const std::vector<std::shared_ptr<ApduResponseApi>>& cardAnticipatedResponses,
        const bool isRatificationMechanismEnabled,
        const ChannelControl channelControl);
 
    void processAtomicClosing(
        const std::vector<std::shared_ptr<AbstractCardCommand>>& cardCommands,
        const bool isRatificationMechanismEnabled,
        const ChannelControl channelControl);
 
    int getCounterValue(const uint8_t sfi, const int counter);
 
    const std::map<const int, const int> getCounterValues(const uint8_t sfi,
                                                          const std::vector<int>& counters);
 
    const std::shared_ptr<ApduResponseApi> createIncreaseDecreaseResponse(
        const bool isDecreaseCommand, const int currentCounterValue, const int incDecValue);
 
    const std::shared_ptr<ApduResponseApi> createIncreaseDecreaseMultipleResponse(
        const bool isDecreaseCommand,
        const std::map<const int, const int>& counterNumberToCurrentValueMap,
        const std::map<const int, const int>& counterNumberToIncDecValueMap);
 
    const std::vector<std::shared_ptr<ApduResponseApi>> getAnticipatedResponses(
        const std::vector<std::shared_ptr<AbstractCardCommand>>& cardCommands);
 
    void processCardCommandsOutOfSession(const ChannelControl channelControl);
 
    void processCardCommandsInSession();
 
    const std::shared_ptr<CardResponseApi> safeTransmit(
        const std::shared_ptr<CardRequestSpi> cardRequest, const ChannelControl channelControl);
 
    const std::vector<uint8_t> getSessionTerminalChallenge();
 
    const std::vector<uint8_t> getSessionTerminalSignature();
 
    void checkCardSignature(const std::vector<uint8_t>& cardSignature);
 
    void checkSvOperationStatus(const std::vector<uint8_t>& cardPostponedData);
 
    void checkSessionOpen();
 
    void checkSessionNotOpen();
 
    void checkCommandsResponsesSynchronization(const size_t commandsNumber, 
                                               const size_t responsesNumber);
 
    bool checkModifyingCommand(const std::shared_ptr<AbstractCardCommand> command,
                               std::atomic<bool>& overflow,
                               std::atomic<int>& neededSessionBufferSpace);
 
    bool isSessionBufferOverflowed(const int sessionBufferSizeConsumed);
 
    void resetModificationsBufferCounter();
 
    CardTransactionManager& prepareUpdateOrWriteBinary(const bool isUpdateCommand,
                                                       const uint8_t sfi,
                                                       const uint8_t offset,
                                                       const std::vector<uint8_t>& data);
 
    CardTransactionManager& prepareIncreaseOrDecreaseCounter(const bool isDecreaseCommand,
                                                             const uint8_t sfi,
                                                             const uint8_t counterNumber,
                                                             const int incDecValue);
 
    CardTransactionManager& prepareIncreaseOrDecreaseCounters(
        const bool isDecreaseCommand,
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToIncDecValueMap);
 
    void processAtomicOpening(
        const WriteAccessLevel writeAccessLevel,
        std::vector<std::shared_ptr<AbstractCardCommand>>& cardCommands);
 
    void prepareInternalSvUndebit(const int amount,
                                  const std::vector<uint8_t>& date,
                                  const std::vector<uint8_t>& time);
 
    void prepareInternalSvDebit(const int amount,
                                const std::vector<uint8_t>& date,
                                const std::vector<uint8_t>& time);
 
    friend std::ostream& operator<<(std::ostream& os, const ApduResponseAdapter& ara);
 
    friend std::ostream& operator<<(std::ostream& os,
                                    const std::shared_ptr<ApduResponseAdapter> ara);
};
 
}
}
}