wtx 0.28.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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

use crate::{
  http::{
    CookieError,
    cookie::{FMT1, FMT2, FMT3, FMT4, SameSite, cookie_generic::CookieGeneric, make_lowercase},
  },
  misc::{ArrayVector, FromRadix10, PercentDecode, Vector, bytes_split_once1, bytes_split1},
};
use chrono::{DateTime, NaiveDateTime, Utc};
use core::{str, time::Duration};

/// A cookie is a small piece of data a server sends to a user's web browser.
#[derive(Debug)]
pub(crate) struct CookieBytes<'bytes> {
  pub(crate) generic: CookieGeneric<&'bytes [u8], &'bytes [u8]>,
}

impl<'bytes> CookieBytes<'bytes> {
  /// Creates a new instance based on a sequence of bytes received from a request.
  #[inline]
  pub(crate) fn parse<'local_bytes, 'vector>(
    bytes: &'local_bytes [u8],
    vector: &'vector mut Vector<u8>,
  ) -> crate::Result<Self>
  where
    'local_bytes: 'bytes,
    'vector: 'bytes,
  {
    let mut semicolons = bytes_split1(bytes, b';');

    let mut cookie: CookieGeneric<&'bytes [u8], &'bytes [u8]> = {
      let first_semicolon = semicolons.next().unwrap_or_default();
      let (name, value) = if let Some(elem) = bytes_split_once1(first_semicolon, b'=') {
        (elem.0.trim_ascii(), elem.1.trim_ascii())
      } else {
        return Err(crate::Error::from(CookieError::IrregularCookie));
      };
      if name.is_empty() {
        return Err(crate::Error::from(CookieError::MissingName));
      }
      let before_name_len = vector.len();
      let has_decoded_name = PercentDecode::new(name).decode(vector)?;
      let before_value_len = vector.len();
      let has_decoded_value = PercentDecode::new(value).decode(vector)?;
      CookieGeneric {
        domain: &[],
        expires: None,
        http_only: false,
        max_age: None,
        name: if has_decoded_name {
          vector.get(before_name_len..before_value_len).unwrap_or_default()
        } else {
          name
        },
        path: &[],
        same_site: None,
        secure: false,
        value: if has_decoded_value {
          vector.get(before_value_len..).unwrap_or_default()
        } else {
          value
        },
      }
    };

    let mut lower_case = ArrayVector::<u8, 12>::new();
    for semicolon in semicolons {
      let (name, value) = if let Some(elem) = bytes_split_once1(semicolon, b'=') {
        (elem.0.trim_ascii(), elem.1.trim_ascii())
      } else {
        return Err(crate::Error::from(CookieError::IrregularCookie));
      };
      make_lowercase::<12>(&mut lower_case, name);
      match (lower_case.as_ref(), value) {
        (b"domain", [_, ..]) => {
          cookie.domain = value;
        }
        (b"expires", [_, ..]) => {
          // SAFETY: `parse_from_str` will check the string content
          let str = unsafe { str::from_utf8_unchecked(value) };
          if let Ok(elem) = NaiveDateTime::parse_from_str(str, FMT1)
            .or_else(|_| NaiveDateTime::parse_from_str(str, FMT2))
            .or_else(|_| NaiveDateTime::parse_from_str(str, FMT3))
            .or_else(|_| NaiveDateTime::parse_from_str(str, FMT4))
            .map(|elem| DateTime::from_naive_utc_and_offset(elem, Utc))
          {
            cookie.expires = Some(elem)
          }
        }
        (b"httponly", _) => cookie.http_only = true,
        (b"max-age", [first, rest @ ..]) => {
          let is_negative = *first == b'-';
          let local_value = if is_negative { rest } else { value };
          if !local_value.iter().all(|el| el.is_ascii_digit()) {
            continue;
          }
          cookie.max_age = Some(if is_negative {
            Duration::ZERO
          } else {
            u64::from_radix_10(value)
              .map(Duration::from_secs)
              .unwrap_or_else(|_| Duration::from_secs(u64::MAX))
          })
        }
        (b"path", [_, ..]) => {
          cookie.path = value;
        }
        (b"samesite", [_, ..]) => {
          make_lowercase::<6>(&mut lower_case, value);
          match lower_case.as_ref() {
            b"lax" => cookie.same_site = Some(SameSite::Lax),
            b"none" => cookie.same_site = Some(SameSite::None),
            b"strict" => cookie.same_site = Some(SameSite::Strict),
            _ => {}
          }
        }
        (b"secure", _) => cookie.secure = true,
        _ => {}
      }
    }

    Ok(Self { generic: cookie })
  }
}