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
//! minihttp is a simple and lightweight http client lib for rust. //! only provide basic http client feature, more like python request. //! minihttp's aim is simple, easy to use, less dependent, smaller binary. //! Enjoy yourself... //! //! #Example //! ## send a get request //! ```no_run //! use minihttp::request::Request; //! //! let mut http = Request::new("http://www.google.com").unwrap(); //! let res = http.get().send().unwrap(); //! println!("status code {}",res.status_code()); //! println!("reason {}",res.reason()); //! println!("body {}",res.text()); //! for (k,v) in res.headers(){ //! println!("{}:{}",k,v); //! } //! ``` //! //! ## send a post request //! ```no_run //! use minihttp::request::Request; //! //! let mut http = Request::new("http://www.google.com").unwrap(); //! let res = http.post().body_str("hello").send().unwrap(); //! println!("status code {}",res.status_code()); //! ``` //! //! ## custom headers //! ```no_run //! use std::collections::HashMap; //! use minihttp::request::Request; //! //! let mut http = Request::new("http://www.google.com").unwrap(); //! let mut headers = HashMap::new(); //! headers.insert("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"); //! let res = http.headers(headers).send().unwrap(); //! println!("status code {}",res.status_code()); //! ``` //! //! ## support https //! ```no_run //! use minihttp::request::Request; //! //! let mut http = Request::new("https://www.google.com").unwrap(); //! let res = http.get().send().unwrap(); //! println!("status code {}",res.status_code()); //! ``` //! //! ## support proxy //! ```no_run //! use minihttp::request::Request; //! //! let mut http = Request::new("https://www.google.com").unwrap(); //! let res = http.proxy("https://127.0.0.1:1080").unwrap().get().send().unwrap(); //! println!("status code {}",res.status_code()); //! ``` //! #![doc(html_root_url = "https://docs.rs/minihttp")] extern crate native_tls; extern crate minihttpse; extern crate miniurl; use miniurl::Url; use minihttpse::Response; use native_tls::TlsConnector; use native_tls::{Error,HandshakeError}; use std::io; use std::net::TcpStream; use std::fmt; ///http request module pub mod request; ///http basic error type #[derive(Debug)] pub enum HttpError { Parse(&'static str), Config(&'static str), Proxy(&'static str), IO(io::Error), SSL(Error), SSLHandshake(HandshakeError<TcpStream>), } impl From<io::Error> for HttpError { fn from(err: io::Error) -> HttpError { HttpError::IO(err) } } impl From<minihttpse::HttpError> for HttpError { fn from(err: minihttpse::HttpError) -> HttpError { let minihttpse::HttpError::Parse(e) = err; HttpError::Parse(e) } } impl From<HandshakeError<TcpStream>> for HttpError { fn from(err: HandshakeError<TcpStream>) -> HttpError { HttpError::SSLHandshake(err) } } impl From<Error> for HttpError { fn from(err: Error) -> HttpError { HttpError::SSL(err) } } impl fmt::Display for HttpError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { HttpError::Parse(ref err) => write!(f, "Parse error: {}", err), HttpError::Config(ref err) => write!(f, "Config error: {}", err), HttpError::IO(ref err) => write!(f, "IO error: {}", err), HttpError::Proxy(ref err) =>write!(f,"Proxy error : {}",err), HttpError::SSL(ref err) => write!(f, "SSL error: {}", err), HttpError::SSLHandshake(ref err) => write!(f, "SSL handshake error: {}", err), } } }