//! Importing a curl command line (as copied from browser devtools, Unix or //! Windows flavour) into a [`Request`]. use std::path::PathBuf; use std::time::Duration; use crate::model::{Body, Header, Method, Part, PartBody, Request}; #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] pub enum CurlImportError { #[error("not a curl command")] NotCurl, #[error("could not split the command into words: {0}")] Tokenize(String), #[error("option {0} needs a value")] MissingValue(String), #[error("no URL in the command")] NoUrl, } /// Whether `text` looks like a curl command (used to detect pastes into the /// URL bar). pub fn looks_like_curl(text: &str) -> bool { let t = text.trim_start(); t.starts_with("curl ") || t.starts_with("curl.exe ") || t.starts_with("curl\n") } const MULTIPART_BOUNDARY: &str = "WebAppBoundary"; pub fn from_curl(cmd: &str) -> Result { let words = tokenize(cmd)?; let mut words = words.into_iter(); match words.next().as_deref() { Some("curl" | "curl.exe") => {} _ => return Err(CurlImportError::NotCurl), } let mut method: Option = None; let mut url: Option = None; let mut headers: Vec
= Vec::new(); let mut data: Vec = Vec::new(); let mut data_file: Option = None; let mut parts: Vec = Vec::new(); let mut get = false; let mut head = false; let mut req = Request::default(); // Expand `-XPOST` and `-sSL` style short options. let mut args: Vec = Vec::new(); for w in words { if w.starts_with('-') && !w.starts_with("--") && w.len() > 2 { let flag = &w[..2]; if takes_value(flag) { args.push(flag.to_string()); args.push(w[2..].to_string()); } else if w[1..].chars().all(|c| c.is_ascii_alphabetic()) { for (i, c) in w[1..].char_indices() { let f = format!("-{c}"); if takes_value(&f) { args.push(f); args.push(w[1 + i + 1..].to_string()); break; } args.push(f); } } else { args.push(w); } } else { args.push(w); } } let mut it = args.into_iter(); while let Some(a) = it.next() { let mut value = |name: &str| it.next().ok_or_else(|| CurlImportError::MissingValue(name.to_string())); match a.as_str() { "-X" | "--request" => method = Method::parse(&value(&a)?.to_ascii_uppercase()), "-H" | "--header" => { let h = value(&a)?; if let Some((n, v)) = h.split_once(':') { let v = v.trim(); // `-H 'X;'` sends an empty header; `-H 'X:'` removes one. if !v.is_empty() { headers.push(Header::new(n.trim(), v)); } } else if let Some(n) = h.strip_suffix(';') { headers.push(Header::new(n.trim(), "")); } } "-d" | "--data" | "--data-ascii" | "--data-binary" => { let v = value(&a)?; match v.strip_prefix('@') { Some(f) if f != "-" => data_file = Some(PathBuf::from(f)), _ => data.push(v), } } "--data-raw" => data.push(value(&a)?), "--data-urlencode" => { let v = value(&a)?; data.push(match v.split_once('=') { Some((k, val)) if !k.is_empty() => format!("{k}={}", urlencode(val)), Some((_, val)) => urlencode(val), None => urlencode(&v), }); } "--json" => { data.push(value(&a)?); if !headers.iter().any(|h| h.name.eq_ignore_ascii_case("content-type")) { headers.push(Header::new("Content-Type", "application/json")); } if !headers.iter().any(|h| h.name.eq_ignore_ascii_case("accept")) { headers.push(Header::new("Accept", "application/json")); } } "-F" | "--form" | "--form-string" => { let v = value(&a)?; if let Some(p) = parse_form(&v, a == "--form-string") { parts.push(p); } } "-u" | "--user" => { let v = value(&a)?; let (user, pass) = v.split_once(':').unwrap_or((&v, "")); headers.push(Header::new("Authorization", format!("Basic {user} {pass}"))); } "-A" | "--user-agent" => headers.push(Header::new("User-Agent", value(&a)?)), "-e" | "--referer" => headers.push(Header::new("Referer", value(&a)?)), "-b" | "--cookie" => { let v = value(&a)?; if v.contains('=') { headers.push(Header::new("Cookie", v)); } } "--url" => url = Some(value(&a)?), "-G" | "--get" => get = true, "-I" | "--head" => head = true, "-k" | "--insecure" => req.directives.other.push(("insecure".into(), String::new())), "-m" | "--max-time" => req.directives.timeout = parse_secs(&value(&a)?), "--connect-timeout" => req.directives.connection_timeout = parse_secs(&value(&a)?), "--http1.1" => req.http_version = Some("HTTP/1.1".into()), "--http2" | "--http2-prior-knowledge" => req.http_version = Some("HTTP/2".into()), "-L" | "--location" | "--compressed" => {} s if takes_value(s) => { value(s)?; } s if s.starts_with('-') => {} // flags without a value we don't need _ => { if url.is_none() { url = Some(a); } } } } let mut url = url.ok_or(CurlImportError::NoUrl)?; // Let curl negotiate compression (and decode it), as `--compressed` does; // a copied `br, zstd` list could ask for encodings we can't decode. headers.retain(|h| !h.name.eq_ignore_ascii_case("accept-encoding")); let has_ct = headers.iter().any(|h| h.name.eq_ignore_ascii_case("content-type")); if get && !data.is_empty() { url.push(if url.contains('?') { '&' } else { '?' }); url.push_str(&data.join("&")); data.clear(); } if !parts.is_empty() { headers.retain(|h| !h.name.eq_ignore_ascii_case("content-type")); headers.push(Header::new( "Content-Type", format!("multipart/form-data; boundary={MULTIPART_BOUNDARY}"), )); req.body = Body::Multipart { boundary: MULTIPART_BOUNDARY.into(), parts, }; } else if let Some(f) = data_file { req.body = Body::FileRef { path: f, substitute: false, }; } else if !data.is_empty() { req.body = Body::Text(data.join("&")); if !has_ct { headers.push(Header::new("Content-Type", "application/x-www-form-urlencoded")); } } req.method = match (method, head, req.body.is_none()) { (Some(m), _, _) => m, (None, true, _) => Method::Head, (None, false, false) => Method::Post, (None, false, true) => Method::Get, }; req.url = url; req.headers = headers; Ok(req) } fn takes_value(flag: &str) -> bool { matches!( flag, "-X" | "--request" | "-H" | "--header" | "-d" | "--data" | "--data-ascii" | "--data-binary" | "--data-raw" | "--data-urlencode" | "--json" | "-F" | "--form" | "--form-string" | "-u" | "--user" | "-A" | "--user-agent" | "-e" | "--referer" | "-b" | "--cookie" | "--url" | "-m" | "--max-time" | "--connect-timeout" | "-o" | "--output" | "-w" | "--write-out" | "-x" | "--proxy" | "-U" | "--proxy-user" | "--cacert" | "--capath" | "-E" | "--cert" | "--key" | "-c" | "--cookie-jar" | "--retry" | "-K" | "--config" | "-T" | "--upload-file" | "--resolve" | "--connect-to" | "--max-redirs" | "-r" | "--range" | "-z" | "--time-cond" ) } fn parse_secs(v: &str) -> Option { v.parse::().ok().map(Duration::from_secs_f64) } fn urlencode(s: &str) -> String { let mut out = String::new(); for b in s.bytes() { if b.is_ascii_alphanumeric() || b"-_.~".contains(&b) { out.push(b as char); } else { out.push_str(&format!("%{b:02X}")); } } out } /// `name=value`, `name=@file;type=x/y;filename=z`, `name= Option { let (name, rest) = v.split_once('=')?; let mut segs = rest.split(';'); let first = segs.next().unwrap_or(""); let mut part = Part { name: name.to_string(), filename: None, headers: Vec::new(), body: PartBody::Text(first.to_string()), }; if literal { part.body = PartBody::Text(rest.to_string()); return Some(part); } if let Some(f) = first.strip_prefix('@') { part.filename = std::path::Path::new(f) .file_name() .map(|n| n.to_string_lossy().into_owned()); part.body = PartBody::File(PathBuf::from(f)); } else if let Some(f) = first.strip_prefix('<') { part.body = PartBody::File(PathBuf::from(f)); } for s in segs { match s.split_once('=') { Some(("type", t)) => part.headers.push(Header::new("Content-Type", t)), Some(("filename", f)) => part.filename = Some(f.trim_matches('"').to_string()), _ => {} } } Some(part) } /// Splits the command into words, handling `\`/`^`/`` ` `` line continuations, /// Windows cmd `^` escapes and bash `$'…'` strings. fn tokenize(cmd: &str) -> Result, CurlImportError> { let mut s = cmd.trim().replace("\r\n", "\n"); let cmd_style = s.contains("^\"") || s.contains("^\n"); if cmd_style { // cmd.exe: `^` escapes the next character, `^` + newline continues. let mut out = String::with_capacity(s.len()); let mut chars = s.chars(); while let Some(c) = chars.next() { if c == '^' { match chars.next() { Some('\n') => out.push(' '), Some(n) => out.push(n), None => {} } } else { out.push(c); } } s = out; } else if s.starts_with("curl.exe") { s = powershell_to_posix(&s.replace("`\n", " ")); } else { s = s.replace("\\\n", " "); } let s = expand_ansi_c_quotes(&s); shell_words::split(&s).map_err(|e| CurlImportError::Tokenize(e.to_string())) } /// PowerShell quoting: `""` and `` `" `` inside double quotes are a literal /// quote; backslashes are literal. fn powershell_to_posix(s: &str) -> String { let mut out = String::with_capacity(s.len()); let mut chars = s.chars().peekable(); let mut in_double = false; let mut in_single = false; while let Some(c) = chars.next() { match c { '"' if !in_single => { if in_double && chars.peek() == Some(&'"') { chars.next(); out.push_str("\\\""); } else { in_double = !in_double; out.push('"'); } } '\'' if !in_double => { in_single = !in_single; out.push(c); } '`' if in_double => match chars.next() { Some('"') => out.push_str("\\\""), Some('n') => out.push('\n'), Some('t') => out.push('\t'), Some(o) => out.push(o), None => {} }, '\\' if in_double => out.push_str("\\\\"), _ => out.push(c), } } out } /// Rewrites bash `$'…'` strings as plain single-quoted strings. fn expand_ansi_c_quotes(s: &str) -> String { let mut out = String::with_capacity(s.len()); let mut chars = s.chars().peekable(); let mut in_single = false; let mut in_double = false; while let Some(c) = chars.next() { match c { '\'' if !in_double => { in_single = !in_single; out.push(c); } '"' if !in_single => { in_double = !in_double; out.push(c); } '\\' if !in_single => { out.push(c); if let Some(n) = chars.next() { out.push(n); } } '$' if !in_single && !in_double && chars.peek() == Some(&'\'') => { chars.next(); let mut val = String::new(); while let Some(c) = chars.next() { match c { '\'' => break, '\\' => match chars.next() { Some('n') => val.push('\n'), Some('t') => val.push('\t'), Some('r') => val.push('\r'), Some('0') => val.push('\0'), Some('x') => { let h: String = std::iter::from_fn(|| chars.next_if(|c| c.is_ascii_hexdigit())) .take(2) .collect(); if let Ok(b) = u8::from_str_radix(&h, 16) { val.push(b as char); } } Some('u') => { let h: String = std::iter::from_fn(|| chars.next_if(|c| c.is_ascii_hexdigit())) .take(4) .collect(); if let Some(ch) = u32::from_str_radix(&h, 16).ok().and_then(char::from_u32) { val.push(ch); } } Some(o) => val.push(o), None => {} }, o => val.push(o), } } out.push('\''); out.push_str(&val.replace('\'', "'\\''")); out.push('\''); } _ => out.push(c), } } out }