ippper 0.6.0

A library for building simple ipp servers
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

use async_compression::futures::bufread;
use ipp::{
    attribute::{IppAttribute, IppAttributes},
    model::{DelimiterTag, StatusCode},
    payload::IppPayload,
    value::{IppName, IppValue},
};
use std::collections::HashSet;
mod reader_stream;
use crate::error::IppError;
pub(crate) use reader_stream::ReaderStream;

pub fn get_ipp_attribute<'a>(
    r: &'a IppAttributes,
    tag: DelimiterTag,
    name: &str,
) -> Option<&'a IppValue> {
    r.groups_of(tag)
        .find_map(|g| g.attributes().get(name))
        .map(|a| a.value())
}

pub fn take_ipp_attribute(
    r: &mut IppAttributes,
    tag: DelimiterTag,
    name: &str,
) -> Option<IppValue> {
    r.groups_mut()
        .iter_mut()
        .filter(|g| g.tag() == tag)
        .find_map(|g| g.attributes_mut().remove(name))
        .map(|a| a.into_value())
}

pub fn decommpress_payload(
    payload: IppPayload,
    compression: Option<&str>,
) -> anyhow::Result<IppPayload> {
    match compression {
        None => Ok(payload),
        Some("none") => Ok(payload),
        Some("gzip") => {
            let decoder = bufread::GzipDecoder::new(futures::io::BufReader::new(payload));
            Ok(IppPayload::new_async(decoder))
        }
        _ => Err(IppError {
            code: StatusCode::ClientErrorCompressionNotSupported,
            msg: StatusCode::ClientErrorCompressionNotSupported.to_string(),
        }
        .into()),
    }
}

pub fn get_requested_attributes(r: &IppAttributes) -> HashSet<&str> {
    get_ipp_attribute(
        r,
        DelimiterTag::OperationAttributes,
        IppAttribute::REQUESTED_ATTRIBUTES,
    )
    .map(|attr| {
        attr.into_iter()
            .filter_map(|e| e.as_keyword().map(|x| x.as_str()))
            .collect::<HashSet<_>>()
    })
    .unwrap_or_else(|| HashSet::from(["all"]))
}

pub fn take_requesting_user_name(r: &mut IppAttributes) -> IppName {
    take_ipp_attribute(r, DelimiterTag::OperationAttributes, "requesting-user-name")
        .and_then(|attr| match attr {
            IppValue::NameWithoutLanguage(name) => Some(name),
            IppValue::NameWithLanguage { name, .. } => Some(name),
            _ => None,
        })
        .unwrap_or_else(|| IppName::new("anonymous").unwrap())
}