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
152
153
154
155
156
157
158
159
160
161
162
163
use std::fmt;

use ::Url;

/// A type that controls the policy on how to handle the following of redirects.
///
/// The default value will catch redirect loops, and has a maximum of 10
/// redirects it will follow in a chain before returning an error.
#[derive(Debug)]
pub struct RedirectPolicy {
    inner: Policy,
}

impl RedirectPolicy {
    /// Create a RedirectPolicy with a maximum number of redirects.
    ///
    /// A `Error::TooManyRedirects` will be returned if the max is reached.
    pub fn limited(max: usize) -> RedirectPolicy {
        RedirectPolicy {
            inner: Policy::Limit(max),
        }
    }

    /// Create a RedirectPolicy that does not follow any redirect.
    pub fn none() -> RedirectPolicy {
        RedirectPolicy {
            inner: Policy::None,
        }
    }

    /// Create a custom RedirectPolicy using the passed function.
    ///
    /// # Note
    ///
    /// The default RedirectPolicy handles redirect loops and a maximum loop
    /// chain, but the custom variant does not do that for you automatically.
    /// The custom policy should have some way of handling those.
    ///
    /// There are variants on `::Error` for both cases that can be used as
    /// return values.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use reqwest::RedirectPolicy;
    /// # let mut client = reqwest::Client::new().unwrap();
    /// client.redirect(RedirectPolicy::custom(|next, previous| {
    ///     if previous.len() > 5 {
    ///         Err(reqwest::Error::TooManyRedirects)
    ///     } else if next.host_str() == Some("example.domain") {
    ///         // prevent redirects to 'example.domain'
    ///         Ok(false)
    ///     } else {
    ///         Ok(true)
    ///     }
    /// }));
    /// ```
    pub fn custom<T>(policy: T) -> RedirectPolicy
    where T: Fn(&Url, &[Url]) -> ::Result<bool> + Send + Sync + 'static {
        RedirectPolicy {
            inner: Policy::Custom(Box::new(policy)),
        }
    }

    fn redirect(&self, next: &Url, previous: &[Url]) -> ::Result<bool> {
        match self.inner {
            Policy::Custom(ref custom) => custom(next, previous),
            Policy::Limit(max) => {
                if previous.len() == max {
                    Err(::Error::TooManyRedirects)
                } else if previous.contains(next) {
                    Err(::Error::RedirectLoop)
                } else {
                    Ok(true)
                }
            },
            Policy::None => Ok(false),
        }
    }
}

impl Default for RedirectPolicy {
    fn default() -> RedirectPolicy {
        RedirectPolicy::limited(10)
    }
}

enum Policy {
    Custom(Box<Fn(&Url, &[Url]) -> ::Result<bool> + Send + Sync + 'static>),
    Limit(usize),
    None,
}

impl fmt::Debug for Policy {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Policy::Custom(..) => f.pad("Custom"),
            Policy::Limit(max) => f.debug_tuple("Limit").field(&max).finish(),
            Policy::None => f.pad("None"),
        }
    }
}

pub fn check_redirect(policy: &RedirectPolicy, next: &Url, previous: &[Url]) -> ::Result<bool> {
    policy.redirect(next, previous)
}

/*
This was the desired way of doing it, but ran in to inference issues when
using closures, since the arguments received are references (&Url and &[Url]),
and the compiler could not infer the lifetimes of those references. That means
people would need to annotate the closure's argument types, which is garbase.

pub trait Redirect {
    fn redirect(&self, next: &Url, previous: &[Url]) -> ::Result<bool>;
}

impl<F> Redirect for F
where F: Fn(&Url, &[Url]) -> ::Result<bool> {
    fn redirect(&self, next: &Url, previous: &[Url]) -> ::Result<bool> {
        self(next, previous)
    }
}
*/

#[test]
fn test_redirect_policy_limit() {
    let policy = RedirectPolicy::default();
    let next = Url::parse("http://x.y/z").unwrap();
    let mut previous = (0..9)
        .map(|i| Url::parse(&format!("http://a.b/c/{}", i)).unwrap())
        .collect::<Vec<_>>();


    match policy.redirect(&next, &previous) {
        Ok(true) => {},
        other => panic!("expected Ok(true), got: {:?}", other)
    }

    previous.push(Url::parse("http://a.b.d/e/33").unwrap());

    match policy.redirect(&next, &previous) {
        Err(::Error::TooManyRedirects) => {},
        other => panic!("expected TooManyRedirects, got: {:?}", other)
    }
}

#[test]
fn test_redirect_policy_custom() {
    let policy = RedirectPolicy::custom(|next, _previous| {
        if next.host_str() == Some("foo") {
            Ok(false)
        } else {
            Ok(true)
        }
    });

    let next = Url::parse("http://bar/baz").unwrap();
    assert_eq!(policy.redirect(&next, &[]).unwrap(), true);

    let next = Url::parse("http://foo/baz").unwrap();
    assert_eq!(policy.redirect(&next, &[]).unwrap(), false);
}