ipp_encoder 1.0.2

Internet Printing Protocol encoder-decoder
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::spec::{
    operation::{OperationID, StatusCode},
    tag::DelimiterTag,
};

use super::{AttributeGroup, IppEncode, IppVersion};

use serde::{Deserialize, Serialize};
use serde_with::{serde_as, DisplayFromStr};
use std::collections::HashMap;

///
/// Operation request or response
///
/// ```
/// -----------------------------------------------
/// |                  version-number             |   2 bytes  - required
/// -----------------------------------------------
/// |               operation-id (request)        |
/// |                      or                     |   2 bytes  - required
/// |               status-code (response)        |
/// -----------------------------------------------
/// |                   request-id                |   4 bytes  - required
/// -----------------------------------------------
/// |                 attribute-group             |   n bytes - 0 or more
/// -----------------------------------------------
/// |              end-of-attributes-tag          |   1 byte   - required
/// -----------------------------------------------
/// |                     data                    |   y bytes  - optional
/// -----------------------------------------------
/// ```
///
/// ----------------------------------------------------------
///
/// ref: [rfc8010](https://datatracker.ietf.org/doc/html/rfc8010#section-3.1)
///
#[serde_as]
#[derive(Serialize, Deserialize, Debug)]
pub struct Operation {
    pub version: IppVersion,
    pub operation_id_or_status_code: u16,
    pub request_id: u32,
    #[serde_as(as = "HashMap<DisplayFromStr, _>")]
    pub attribute_groups: HashMap<DelimiterTag, AttributeGroup>,
    #[serde(skip)]
    /// additional data in trailing bytes
    pub data: Vec<u8>,
}

impl IppEncode for Operation {
    fn from_ipp(bytes: &[u8], offset: usize) -> (usize, Self) {
        let mut shifting_offset = offset;

        // read version.major
        let slice: [u8; 1] = bytes[shifting_offset..shifting_offset + 1]
            .try_into()
            .unwrap();
        let major = u8::from_be_bytes(slice);
        shifting_offset += slice.len();

        // read version.minor
        let slice: [u8; 1] = bytes[shifting_offset..shifting_offset + 1]
            .try_into()
            .unwrap();
        let minor = u8::from_be_bytes(slice);
        shifting_offset += slice.len();

        // read operation-id or status-code
        let slice: [u8; 2] = bytes[shifting_offset..shifting_offset + 2]
            .try_into()
            .unwrap();
        let operation_id_or_status_code = u16::from_be_bytes(slice);
        shifting_offset += slice.len();

        // read request-id
        let slice: [u8; 4] = bytes[shifting_offset..shifting_offset + 4]
            .try_into()
            .unwrap();
        let request_id = u32::from_be_bytes(slice);
        shifting_offset += slice.len();

        // read attribute groups
        let (delta, attribute_groups): (usize, HashMap<DelimiterTag, AttributeGroup>) =
            HashMap::from_ipp(bytes, shifting_offset);
        shifting_offset += delta;

        // read additional data (trailing bytes)
        let data = (&bytes[shifting_offset..]).to_vec();

        (
            shifting_offset - offset,
            Self {
                version: IppVersion { major, minor },
                request_id,
                operation_id_or_status_code,
                attribute_groups,
                data,
            },
        )
    }

    fn to_ipp(&self) -> Vec<u8> {
        // write version major
        let major_bytes = self.version.major.to_be_bytes().to_vec();

        // write version minor
        let minor_bytes = self.version.minor.to_be_bytes().to_vec();

        // write operation-id or status-code
        let operation_or_status_bytes = self.operation_id_or_status_code.to_be_bytes().to_vec();

        // write request-id
        let request_id_bytes = self.request_id.to_be_bytes().to_vec();

        // write attribute groups
        let attribute_groups_bytes = self.attribute_groups.to_ipp();

        [
            major_bytes,
            minor_bytes,
            operation_or_status_bytes,
            request_id_bytes,
            attribute_groups_bytes,
            self.data.to_vec(),
        ]
        .concat()
    }

    fn ipp_len(&self) -> usize {
        self.version.major.to_be_bytes().len()
            + self.version.minor.to_be_bytes().len()
            + self.operation_id_or_status_code.to_be_bytes().len()
            + self.request_id.to_be_bytes().len()
            + self.attribute_groups.ipp_len()
            + self.data.len()
    }
}

impl Operation {
    pub fn operation_id(&self) -> Option<OperationID> {
        OperationID::from_repr(self.operation_id_or_status_code as usize)
    }
    pub fn status_code(&self) -> Option<StatusCode> {
        StatusCode::from_repr(self.operation_id_or_status_code as usize)
    }

    pub fn to_json(&self) -> String {
        // FIXME: handle error gracefully
        serde_json::to_string(self).unwrap()
    }
}