Transaction.hpp

Go to the documentation of this file.

// ======================================================================
// \title  Transaction.hpp
// \brief  CFDP Transaction state machine class for TX and RX operations
//
// This file is a port of transaction state machine definitions from the following files
// from the NASA Core Flight System (cFS) CFDP (CF) Application, version 3.0.0,
// adapted for use within the F-Prime (F') framework:
// - cf_cfdp_r.h (receive transaction state machine definitions)
// - cf_cfdp_s.h (send transaction state machine definitions)
// - cf_cfdp_dispatch.h (transaction dispatch definitions)
//
// This file contains the unified interface for CFDP transaction state
// machines, encompassing both TX (send) and RX (receive) operations.
// The implementation is split across TransactionTx.cpp and
// TransactionRx.cpp for maintainability.
//
// ======================================================================
//
// NASA Docket No. GSC-18,447-1
//
// Copyright (c) 2019 United States Government as represented by the
// Administrator of the National Aeronautics and Space Administration.
// All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ======================================================================

#ifndef Svc_Ccsds_CfdpTransaction_HPP
#define Svc_Ccsds_CfdpTransaction_HPP

#include <Fw/Types/BasicTypes.hpp>

#include <Svc/Ccsds/CfdpManager/Types/PduBase.hpp>
#include <Svc/Ccsds/CfdpManager/Types/Types.hpp>

namespace Svc {
namespace Ccsds {
namespace Cfdp {

// Forward declarations
class CfdpManager;
class Engine;
class Channel;
class Transaction;

// ======================================================================
// Dispatch Table Type Definitions
// ======================================================================

using StateSendFunc = void (Transaction::*)();

using StateRecvFunc = void (Transaction::*)(const Fw::Buffer& buffer);

struct TxnSendDispatchTable {
    StateSendFunc tx[static_cast<U32>(TxnState::TXN_STATE_INVALID)]; 
};

struct TxnRecvDispatchTable {
    StateRecvFunc rx[static_cast<U32>(TxnState::TXN_STATE_INVALID)];
};

struct FileDirectiveDispatchTable {
    StateRecvFunc fdirective[static_cast<U32>(FileDirective::FILE_DIRECTIVE_INVALID_MAX)];
};

struct RSubstateDispatchTable {
    const FileDirectiveDispatchTable* state[static_cast<U32>(RxSubState::RX_SUB_STATE_NUM_STATES)];
};

struct SSubstateRecvDispatchTable {
    const FileDirectiveDispatchTable* substate[static_cast<U32>(TxSubState::TX_SUB_STATE_NUM_STATES)];
};

struct SSubstateSendDispatchTable {
    StateSendFunc substate[static_cast<U32>(TxSubState::TX_SUB_STATE_NUM_STATES)];
};

class Transaction {
    friend class Engine;
    friend class Channel;
    friend class CfdpManagerTester;

  public:
    // ----------------------------------------------------------------------
    // Construction and Destruction
    // ----------------------------------------------------------------------

    Transaction(Channel* channel, U8 channelId, Engine* engine, CfdpManager* manager);

    ~Transaction();

    void reset();

    void initTxFile(Class::T cfdp_class, Keep::T keep, U8 chan, U8 priority);

    static CListTraverseStatus findBySequenceNumberCallback(CListNode* node, void* context);

    static CListTraverseStatus prioritySearchCallback(CListNode* node, void* context);

    // ----------------------------------------------------------------------
    // Accessors
    // ----------------------------------------------------------------------

    History* getHistory() const { return m_history; }

    U8 getPriority() const { return m_priority; }

    U8 getChannelId() const { return m_chan_num; }

    Class::T getClass() const { return m_txn_class; }

    TxnState getState() const { return m_state; }

    // ----------------------------------------------------------------------
    // TX State Machine - Implemented in TransactionTx.cpp
    // ----------------------------------------------------------------------

    /************************************************************************/
    void s1Recv(const Fw::Buffer& buffer);

    /************************************************************************/
    void s2Recv(const Fw::Buffer& buffer);

    /************************************************************************/
    void s1Tx();

    /************************************************************************/
    void s2Tx();

    /************************************************************************/
    void sAckTimerTick();

    /************************************************************************/
    void sTick(I32* cont);

    /************************************************************************/
    void sTickNak(I32* cont);

    /************************************************************************/
    void sCancel();

    /************************************************************************/
    void s1SubstateSendEof();

    /************************************************************************/
    void s2SubstateSendEof();

    /************************************************************************/
    void sSubstateSendFileData();

    /************************************************************************/
    void s2SubstateSendFileData();

    /************************************************************************/
    void sSubstateSendMetadata();

    /************************************************************************/
    void s2EarlyFin(const Fw::Buffer& pdu);

    /************************************************************************/
    void s2Fin(const Fw::Buffer& pdu);

    /************************************************************************/
    void s2Nak(const Fw::Buffer& pdu);

    /************************************************************************/
    void s2NakArm(const Fw::Buffer& pdu);

    /************************************************************************/
    void s2EofAck(const Fw::Buffer& pdu);

  private:
    /***********************************************************************
     *
     * Handler routines for send-file transactions
     * These are not called from outside this module, but are declared here so they can be unit tested
     *
     ************************************************************************/

    /************************************************************************/
    Status::T sSendEof();

    Status::T sSendFileData(FileSize foffs, FileSize bytes_to_read, U8 calc_crc, FileSize* bytes_processed);

    Status::T sCheckAndRespondNak(bool* nakProcessed);

    Status::T sSendFinAck();

  public:
    // ----------------------------------------------------------------------
    // RX State Machine - Implemented in TransactionRx.cpp
    // ----------------------------------------------------------------------

    /************************************************************************/
    void r1Recv(const Fw::Buffer& buffer);

    /************************************************************************/
    void r2Recv(const Fw::Buffer& buffer);

    /************************************************************************/
    void rAckTimerTick();

    /************************************************************************/
    void rTick(I32* cont);

    /************************************************************************/
    void rCancel();

    /************************************************************************/
    void rInit();

    /************************************************************************/
    void r2SetFinTxnStatus(TxnStatus txn_stat);

    /************************************************************************/
    void r1Reset();

    /************************************************************************/
    void r2Reset();

    /************************************************************************/
    Status::T rCheckCrc(U32 expected_crc);

    /************************************************************************/
    void r2Complete(I32 ok_to_send_nak);

    // ----------------------------------------------------------------------
    // Dispatch Methods (ported from cf_cfdp_dispatch.c)
    // ----------------------------------------------------------------------

    /************************************************************************/
    void rDispatchRecv(const Fw::Buffer& buffer, const RSubstateDispatchTable* dispatch, StateRecvFunc fd_fn);

    /************************************************************************/
    void sDispatchRecv(const Fw::Buffer& buffer, const SSubstateRecvDispatchTable* dispatch);

    /************************************************************************/
    void sDispatchTransmit(const SSubstateSendDispatchTable* dispatch);

    /************************************************************************/
    void txStateDispatch(const TxnSendDispatchTable* dispatch);

  private:
    /************************************************************************/
    Status::T rProcessFd(const Fw::Buffer& pdu);

    /************************************************************************/
    Status::T rSubstateRecvEof(const Fw::Buffer& pdu);

    /************************************************************************/
    void r1SubstateRecvEof(const Fw::Buffer& pdu);

    /************************************************************************/
    void r2SubstateRecvEof(const Fw::Buffer& pdu);

    /************************************************************************/
    void r1SubstateRecvFileData(const Fw::Buffer& pdu);

    /************************************************************************/
    void r2SubstateRecvFileData(const Fw::Buffer& pdu);

    /************************************************************************/
    void r2GapCompute(const Chunk* chunk, NakPdu& nak);

    static void r2GapComputeWrapper(const Chunk* chunk, void* opaque);

    /************************************************************************/
    Status::T rSubstateSendNak();

    /************************************************************************/
    Status::T r2CalcCrcChunk();

    /************************************************************************/
    Status::T r2SubstateSendFin();

    /************************************************************************/
    void r2RecvFinAck(const Fw::Buffer& pdu);

    /************************************************************************/
    void r2RecvMd(const Fw::Buffer& pdu);

    /************************************************************************/
    void rSendInactivityEvent();

  private:
    // ----------------------------------------------------------------------
    // Member Variables
    // ----------------------------------------------------------------------

    TxnState m_state;

    Class::T m_txn_class;

    History* m_history;

    CfdpChunkWrapper* m_chunks;

    Timer m_inactivity_timer;

    Timer m_ack_timer;

    FileSize m_fsize;

    FileSize m_foffs;

    Os::File m_fd;

    CFDP::Checksum m_crc;

    Keep::T m_keep;

    U8 m_chan_num;

    U8 m_priority;

    TransactionInitType m_initType;

    CListNode m_cl_node;

    Playback* m_pb;

    CfdpStateData m_state_data;

    CfdpStateFlags m_flags;

    CfdpManager* m_cfdpManager;

    Channel* m_chan;

    Engine* m_engine;
};

}  // namespace Cfdp
}  // namespace Ccsds
}  // namespace Svc

#endif  // Svc_Ccsds_CfdpTransaction_HPP