potrContext.h

Go to the documentation of this file.

 
#ifndef POTR_CONTEXT_H
#define POTR_CONTEXT_H
 
#include <stdint.h>
 
#include <porter_type.h>
 
#include "protocol/window.h"
#include "infra/compress/compress.h"
#include "infra/crypto/crypto.h"
#include "infra/potrSendQueue.h"
 
#ifndef _WIN32
    #include <pthread.h>
    #include <netinet/in.h>
    typedef int                PotrSocket;
    typedef pthread_t          PotrThread;
    typedef pthread_mutex_t    PotrMutex;
    typedef pthread_cond_t     PotrCondVar;
    #define POTR_INVALID_SOCKET (-1)
#else /* _WIN32 */
    #include <winsock2.h>
    #include <ws2tcpip.h>
    typedef SOCKET             PotrSocket;
    typedef HANDLE             PotrThread;
    typedef CRITICAL_SECTION   PotrMutex;
    typedef CONDITION_VARIABLE PotrCondVar;
    #define POTR_INVALID_SOCKET INVALID_SOCKET
#endif /* _WIN32 */

static inline int potr_is_tcp_type(PotrType t)
{
    return t == POTR_TYPE_TCP || t == POTR_TYPE_TCP_BIDIR;
}

static inline int potr_is_raw_type(PotrType t)
{
    return t == POTR_TYPE_UNICAST_RAW   ||
           t == POTR_TYPE_MULTICAST_RAW ||
           t == POTR_TYPE_BROADCAST_RAW;
}

static inline PotrType potr_raw_base_type(PotrType t)
{
    switch (t)
    {
        case POTR_TYPE_UNICAST_RAW:   return POTR_TYPE_UNICAST;
        case POTR_TYPE_MULTICAST_RAW: return POTR_TYPE_MULTICAST;
        case POTR_TYPE_BROADCAST_RAW: return POTR_TYPE_BROADCAST;
        case POTR_TYPE_UNICAST:
        case POTR_TYPE_MULTICAST:
        case POTR_TYPE_BROADCAST:
        case POTR_TYPE_UNICAST_BIDIR:
        case POTR_TYPE_UNICAST_BIDIR_N1:
        case POTR_TYPE_TCP:
        case POTR_TYPE_TCP_BIDIR:
        default:                      return t;
    }
}

#define POTR_NACK_DEDUP_SLOTS 8U

typedef struct
{
    uint32_t ack_num; 
    uint32_t _pad;    
    uint64_t time_ms; 
} PotrNackDedupEntry;

typedef struct PotrPeerContext_
{
    PotrPeerId  peer_id; 
    int         active;  
 
    /* 自セッション (このピア宛の送信に使用) */
    uint32_t session_id;        
    uint32_t _pad_session;      
    int64_t  session_tv_sec;    
    int32_t  session_tv_nsec;   
 
    /* ピアセッション追跡 */
    uint32_t peer_session_id;       
    int64_t  peer_session_tv_sec;   
    int32_t  peer_session_tv_nsec;  
    int      peer_session_known;    
 
    /* 送受信ウィンドウ (ピアごと独立) */
    PotrWindow send_window;        
    PotrMutex  send_window_mutex;  
    PotrWindow recv_window;        
 
    /* フラグメント結合 (ピアごと独立) */
    uint8_t *frag_buf;       
    size_t   frag_buf_len;   
    int      frag_compressed;
 
    /* ヘルスチェック */
    volatile int health_alive;      
    int64_t      last_recv_tv_sec;  
    int32_t      last_recv_tv_nsec; 
    uint32_t     _pad_nack_dedup;   
 
    /* NACK 重複抑制 */
    PotrNackDedupEntry nack_dedup_buf[POTR_NACK_DEDUP_SLOTS]; 
    uint8_t            nack_dedup_next;                        
    uint8_t            _pad_reorder[3];                        
 
    /* リオーダーバッファタイムアウト管理 */
    int      reorder_pending;       
    uint32_t reorder_nack_num;      
    uint32_t _pad_reorder_dl;       
    int64_t  reorder_deadline_sec;  
    int32_t  reorder_deadline_nsec; 
 
    /* マルチパス: ピアごとの送信先 (recvfrom で学習)
     * インデックスは ctx->sock[] / src_addr[] と直接対応する。
     * 未使用スロットは dest_addr[k].sin_family == 0 (AF_UNSPEC) で判定する。 */
    struct sockaddr_in dest_addr[POTR_MAX_PATH];          
    int                n_paths;                           
    int64_t            path_last_recv_sec[POTR_MAX_PATH]; 
    int32_t            path_last_recv_nsec[POTR_MAX_PATH];
} PotrPeerContext;

struct PotrContext_
{
    PotrRecvCallback callback;                         
    PotrThread       recv_thread[POTR_MAX_PATH];       
    PotrThread       health_thread[POTR_MAX_PATH];     
    PotrMutex        health_mutex[POTR_MAX_PATH];      
    PotrCondVar      health_wakeup[POTR_MAX_PATH];     
    PotrServiceDef   service;      
    PotrGlobalConfig global;       
    PotrWindow       send_window;       
    PotrMutex        send_window_mutex; 
    PotrWindow       recv_window;       
 
    /* マルチパス: ソケット配列 */
    PotrSocket         sock[POTR_MAX_PATH];              
    int                n_path;                               
 
    volatile int     running[POTR_MAX_PATH];        
    volatile int     health_running[POTR_MAX_PATH]; 
    volatile int     health_alive;                  
    PotrRole         role;            
 
    /* 解決済みアドレス (各パス分) */
    struct in_addr     src_addr_resolved[POTR_MAX_PATH]; 
    struct in_addr     dst_addr_resolved[POTR_MAX_PATH]; 
    struct sockaddr_in dest_addr[POTR_MAX_PATH];         
 
    /* 自セッション識別子 (potrOpenService 時に決定) */
    uint32_t         session_id;        
    int64_t          session_tv_sec;    
    int32_t          session_tv_nsec;   
 
    /* 相手セッション追跡 (受信者が使用) */
    uint32_t         peer_session_id;      
    int64_t          peer_session_tv_sec;  
    int32_t          peer_session_tv_nsec; 
    int              peer_session_known;   
 
    /* 受信者: パスごとの送信者ポートキャッシュ (src_port=0 対応) */
    uint16_t           peer_port[POTR_MAX_PATH]; 
 
    /* ヘルスチェック: 最終受信時刻 (受信者が使用。CLOCK_MONOTONIC 基準)。 */
    int32_t          last_recv_tv_nsec;   
    uint32_t         _pad_lastrecv;       
    int64_t          last_recv_tv_sec;    
 
    /* 受信者: パスごとの最終受信時刻 (パス単位の peer_port クリア用。CLOCK_MONOTONIC 基準)。 */
    int64_t            path_last_recv_sec[POTR_MAX_PATH];  
    int32_t            path_last_recv_nsec[POTR_MAX_PATH]; 
 
    size_t           frag_buf_len;       
    int              frag_compressed;   
    uint32_t         _pad_frag;         
    uint8_t         *frag_buf;          
    uint8_t         *compress_buf;      
    size_t           compress_buf_size; 
    uint8_t         *crypto_buf;        
    size_t           crypto_buf_size;   
    uint8_t         *recv_buf;          
    uint8_t         *send_wire_buf;     
 
    /* 非同期送信 (POTR_ROLE_SENDER のみ使用) */
    PotrThread        send_thread;          
    volatile int      send_thread_running;  
    uint32_t          _pad_send_thread;     
    volatile uint64_t last_send_ms;         
 
    /* 送信者: NACK 重複抑制リングバッファ */
    PotrNackDedupEntry nack_dedup_buf[POTR_NACK_DEDUP_SLOTS]; 
    uint8_t            nack_dedup_next;                        
    uint8_t            _pad_nack_dedup[7];                     
 
    /* 受信者: リオーダーバッファタイムアウト管理 (reorder_timeout_ms > 0 のときのみ使用) */
    int      reorder_pending;        
    uint32_t reorder_nack_num;       
    int64_t  reorder_deadline_sec;   
    int32_t  reorder_deadline_nsec;  
    uint32_t _pad_reorder;           
 
    PotrSendQueue  send_queue;          
 
    /* N:1 マルチピアモード専用フィールド (is_multi_peer == 1 のときのみ有効) */
    int              is_multi_peer;    
    uint32_t         _pad_multi_peer; 
    PotrPeerContext *peers;            
    int              max_peers;      
    int              n_peers;        
    PotrMutex        peers_mutex;    
    uint32_t         next_peer_id;   
 
    /* --- TCP 接続管理 (POTR_TYPE_TCP / POTR_TYPE_TCP_BIDIR のみ有効) --- */
    PotrSocket         tcp_listen_sock[POTR_MAX_PATH]; 
    PotrSocket         tcp_conn_fd[POTR_MAX_PATH];     
    volatile int       tcp_active_paths;               
    uint32_t           _pad_tcp_connected[2];          
    PotrMutex          tcp_send_mutex[POTR_MAX_PATH];  
 
    /* recv_window 保護 (TCP v2: 複数 recv スレッドが同一 recv_window にアクセスするため) */
    PotrMutex          recv_window_mutex;              
 
    /* connect/accept スレッド */
    PotrThread         connect_thread[POTR_MAX_PATH];         
    volatile int       connect_thread_running[POTR_MAX_PATH]; 
 
    /* 切断通知 (recv/health スレッド → connect スレッドへの通知) */
    PotrMutex          tcp_state_mutex;            
    PotrCondVar        tcp_state_cv;               
 
    /* PING 応答追跡 (SENDER health スレッドが参照、TCP recv スレッドが更新) */
    volatile uint64_t  tcp_last_ping_recv_ms[POTR_MAX_PATH];     
 
    /* PING 要求到着追跡 (RECEIVER recv スレッドが参照・更新。RECEIVER 側 PING 到着タイムアウト監視に使用) */
    volatile uint64_t  tcp_last_ping_req_recv_ms[POTR_MAX_PATH]; 
 
    /* 送信バッファ満杯ログ抑制 (TCP v2 送信スレッド用) */
    int                buf_full_suppress_cnt[POTR_MAX_PATH];     
 
    /* TCP セッション確立排他制御 (RECEIVER TCP のみ使用)。
     * 複数 path の accept スレッドが並行して session_id 判定を行う際の競合を防ぐ。
     * potr_connect_thread_start で初期化、potr_connect_thread_stop で破棄する。 */
    PotrMutex          session_establish_mutex;
 
    /* TCP 先読みバッファ (path ごと)。
     * accept スレッドが session 判定のために読み取った最初の 1 パケット分のバイト列を
     * recv スレッドに引き渡す。accept スレッドが書き込み後に recv スレッドを起動するため
     * 書き込み→起動→読み出しの順序が保証され、mutex は不要。
     * recv スレッドは起動直後に先読みパケットを処理し tcp_first_pkt_len[i] を 0 に戻す。 */
    uint8_t           *tcp_first_pkt_buf[POTR_MAX_PATH]; 
    size_t             tcp_first_pkt_len[POTR_MAX_PATH];  
};
 
#endif /* POTR_CONTEXT_H */