libdvb 0.3.1

Interface for DVB-API v5 devices in Linux
Documentation 
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
125
126
127
128
129
130
131
132
133
134
135

//! Transport  Protocol  Data  Unit (TPDU)
//!
//! en50221 7.1
//! The Transport Layer of the Command Interface operates on top of a Link
//! Layer provided by the particular physical implementation used.
//! The transport protocol is a command-response protocol where the host
//! sends a command to the module, using a Command Transport Protocol Data
//! Unit (C_TPDU) and waits for a response from the module with a Response
//! Transport Protocol Data Unit (R_TPDU).
//! The module cannot initiate communication: it must wait for the host to
//! poll it or send it data first.


use {
    std::{
        io::{
            Write,
            IoSlice,
        },
    },

    super::{
        asn1,
        CaDevice,
        spdu,
    },

    crate::error::{
        Error,
        Result,
    },
};


pub use {
    ca_tpdu_tag::*,
};


pub const TPDU_SIZE_MAX: usize = 2048;


/// en50221 A.4.1.13: List of transport tags
mod ca_tpdu_tag {
    pub const TT_SB: u8                             = 0x80;
    pub const TT_RCV: u8                            = 0x81;
    pub const TT_CREATE_TC: u8                      = 0x82;
    pub const TT_CTC_REPLY: u8                      = 0x83;
    pub const TT_DELETE_TC: u8                      = 0x84;
    pub const TT_DTC_REPLY: u8                      = 0x85;
    pub const TT_REQUEST_TC: u8                     = 0x86;
    pub const TT_NEW_TC: u8                         = 0x87;
    pub const TT_TC_ERROR: u8                       = 0x88;
    pub const TT_DATA_LAST: u8                      = 0xA0;
    pub const TT_DATA_MORE: u8                      = 0xA1;
}


pub fn _read(ca: &mut CaDevice, data: &[u8]) -> Result<()> {
    // TODO: read packet

    if data.len() < 4 {
        return Err(Error::InvalidData("invalid ca tpdu packet size".to_owned()));
    }

    if data[1] == 0 /* TODO: || data[1] > ca.slots.len() */ {
        return Err(Error::InvalidData(format!("invalid ca tpdu slot id {}", data[1])));
    }

    let slot_id = data[1] - 1;
    let tag = data[2];

    match tag {
        /* Create Transport Connection reply */
        TT_CTC_REPLY => {
            // TODO: slot is active now
        }
        /* Delete Transport Connection reply */
        TT_DTC_REPLY => {
            //
        }

        TT_DATA_MORE => {
            // TODO: save data to buffer
        }
        TT_DATA_LAST => {
            // TODO: save data to buffer
            spdu::handle(ca, slot_id, &[])?;
        }

        TT_SB => {}
        _ => {
            return Err(Error::InvalidData(format!("invalid ca tpdu tag 0x{:02X}", tag)));
        }
    }

    Ok(())
}


/// Writes TPDU to the CA device
pub fn send(ca: &CaDevice, slot_id: u8, tag: u8, data: &[u8]) -> Result<()> {
    if data.len() >= TPDU_SIZE_MAX {
        return Err(Error::InvalidData("ca tpdu packet is to large".to_owned()));
    }

    // TODO: queue and send messages only if module ready
    // TODO: timeout

    let t_c_id = slot_id + 1;

    let mut header: Vec<u8> = Vec::with_capacity(8);
    header.push(slot_id);
    header.push(t_c_id);
    header.push(tag);

    asn1::encode(data.len() as u16 + 1, &mut header);
    header.push(t_c_id);

    let bufs = &mut [
        IoSlice::new(&header),
        IoSlice::new(data),
    ];

    // TODO: write_all_vectored
    (&ca.file).write_vectored(bufs)?;

    Ok(())
}


/// Init transport layer for slot
pub fn init(ca: &CaDevice, slot_id: u8) -> Result<()> {
    send(ca, slot_id, TT_CREATE_TC, &[])
}