ipp 0.0.2

IPP print protocol implementation for Rust
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

//!
//! IPP client
//!
use hyper::client::request::Request;
use hyper::method::Method;
use hyper::Url;
use hyper::status::StatusCode;
use hyper::header::{ContentType};
use mime::Mime;
use std::io::BufWriter;

use request::IppRequest;
use response::IppResponse;
use ::{IppError, Result};
use attribute::{IppAttributeList};
use parser::IppParser;

/// IPP client
///
/// IPP client is responsible for sending requests to IPP server
pub struct IppClient {}

impl IppClient {
    /// Create new instance of the client
    pub fn new() -> IppClient {
        IppClient {}
    }

    /// Send request and return response
    pub fn send_raw<'a>(&self, request: &'a mut IppRequest<'a>) -> Result<IppResponse> {
        match Url::parse(request.uri()) {
            Ok(url) => {
                let mut http_req_fresh = try!(Request::new(Method::Post, url));
                let mime: Mime = "application/ipp".parse().unwrap();
                http_req_fresh.headers_mut().set(ContentType(mime));
                let mut http_req_stream = try!(http_req_fresh.start());
                try!(request.write(&mut BufWriter::new(&mut http_req_stream)));

                let mut http_resp = try!(http_req_stream.send());
                debug!("HTTP reply headers: {}", http_resp.headers);
                if http_resp.status == StatusCode::Ok {
                    let mut parser = IppParser::new(&mut http_resp);
                    let resp = try!(IppResponse::from_parser(&mut parser));

                    Ok(resp)
                } else {
                    error!("HTTP error: {}", http_resp.status);
                    Err(IppError::RequestError)
                }
            }
            Err(_) => {
                error!("Invalid URI: {}", request.uri());
                Err(IppError::RequestError)
            }
        }
    }

    /// Send request and return list of attributes if it succeeds
    pub fn send<'a>(&self, request: &'a mut IppRequest<'a>) -> Result<IppAttributeList> {
        match self.send_raw(request) {
            Ok(resp) => {
                if resp.header().status > 3 {
                    // IPP error
                    Err(IppError::StatusError(resp.header().status))
                } else {
                    Ok(resp.attributes().clone())
                }
            }
            Err(err) => Err(err)
        }
    }
}