From 6608acef719ea201d8d6ce9df7d8907aa770c959 Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Fri, 11 Dec 2020 22:14:42 +0800 Subject: Read version of rustc that compiled proc macro With Jay Somedon --- crates/proc_macro_api/Cargo.toml | 2 + crates/proc_macro_api/src/lib.rs | 82 +++++++++++++++++++++++++++++++++++----- 2 files changed, 74 insertions(+), 10 deletions(-) (limited to 'crates') diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml index f09726223..a72ae236a 100644 --- a/crates/proc_macro_api/Cargo.toml +++ b/crates/proc_macro_api/Cargo.toml @@ -19,3 +19,5 @@ jod-thread = "0.1.1" tt = { path = "../tt", version = "0.0.0" } base_db = { path = "../base_db", version = "0.0.0" } stdx = { path = "../stdx", version = "0.0.0" } +snap = "1" +object = "0.22.0" diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index 2ea456fb0..cec854746 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -5,16 +5,11 @@ //! is used to provide basic infrastructure for communication between two //! processes: Client (RA itself), Server (the external program) -mod rpc; -mod process; pub mod msg; +mod process; +mod rpc; -use std::{ - ffi::OsStr, - io, - path::{Path, PathBuf}, - sync::Arc, -}; +use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, path::{Path, PathBuf}, sync::Arc}; use base_db::{Env, ProcMacro}; use tt::{SmolStr, Subtree}; @@ -23,6 +18,9 @@ use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread}; pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind}; +use object::read::{File as BinaryFile, Object, ObjectSection}; +use snap::read::FrameDecoder as SnapDecoder; + #[derive(Debug, Clone)] struct ProcMacroProcessExpander { process: Arc, @@ -71,7 +69,10 @@ impl ProcMacroClient { args: impl IntoIterator>, ) -> io::Result { let (thread, process) = ProcMacroProcessSrv::run(process_path, args)?; - Ok(ProcMacroClient { process: Arc::new(process), thread }) + Ok(ProcMacroClient { + process: Arc::new(process), + thread, + }) } pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec { @@ -98,8 +99,69 @@ impl ProcMacroClient { dylib_path: dylib_path.into(), }); - ProcMacro { name, kind, expander } + ProcMacro { + name, + kind, + expander, + } }) .collect() } + + // This is used inside self.read_version() to locate the ".rustc" section + // from a proc macro crate's binary file. + fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> &'a [u8] { + BinaryFile::parse(dylib_binary) + .unwrap() + .section_by_name(section_name) + .unwrap() + .data() + .unwrap() + } + + // Check the version of rustc that was used to compile a proc macro crate's + // binary file. + // A proc macro crate binary's ".rustc" section has following byte layout: + // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes + // * ff060000 734e6150 is followed, it's the snappy format magic bytes, + // means bytes from here(including this sequence) are compressed in + // snappy compression format. Version info is here inside, so decompress + // this. + // The bytes you get after decompressing the snappy format portion has + // following layout: + // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) + // * [crate root bytes] next 4 bytes is to store crate root position, + // according to rustc's source code comment + // * [length byte] next 1 byte tells us how many bytes we should read next + // for the version string's utf8 bytes + // * [version string bytes encoded in utf8] <- GET THIS BOI + // * [some more bytes that we don really care but still there] :-) + // Check this issue for more about the bytes layout: + // https://github.com/rust-analyzer/rust-analyzer/issues/6174 + fn read_version(&self, dylib_path: &Path) -> String { + let dylib_binary = fsread(dylib_path).unwrap(); + + let dot_rustc = self.read_section(&dylib_binary, ".rustc"); + + let snappy_portion = &dot_rustc[8..]; + + let mut snappy_decoder = SnapDecoder::new(snappy_portion); + + // the bytes before version string bytes, so this basically is: + // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5] + // 4 bytes for [crate root bytes] + // 1 byte for length of version string + // so 13 bytes in total, and we should check the 13th byte + // to know the length + let mut bytes_before_version = [0u8; 13]; + snappy_decoder + .read_exact(&mut bytes_before_version) + .unwrap(); + let length = bytes_before_version[12]; // what? can't use -1 indexing? + + let mut version_string_utf8 = vec![0u8; length as usize]; + snappy_decoder.read_exact(&mut version_string_utf8).unwrap(); + let version_string = String::from_utf8(version_string_utf8).unwrap(); + version_string + } } -- cgit v1.2.3 From 8fd7cd74067445484fbbd3f78e715c4fe24b004c Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Wed, 23 Dec 2020 17:57:43 +0800 Subject: Configure object crate's feature Signed-off-by: Jay Somedon --- crates/proc_macro_api/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml index a72ae236a..5b0a05dff 100644 --- a/crates/proc_macro_api/Cargo.toml +++ b/crates/proc_macro_api/Cargo.toml @@ -20,4 +20,4 @@ tt = { path = "../tt", version = "0.0.0" } base_db = { path = "../base_db", version = "0.0.0" } stdx = { path = "../stdx", version = "0.0.0" } snap = "1" -object = "0.22.0" +object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] } -- cgit v1.2.3 From 55d73bc6754c351dead6ab4d4b57ddaa347734d6 Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Wed, 23 Dec 2020 21:24:53 +0800 Subject: Fix multiple issues from code review * check metadata version * use memmap * use Result instead of unwrap with Jay Somedon --- crates/proc_macro_api/Cargo.toml | 1 + crates/proc_macro_api/src/lib.rs | 44 ++++++++++++++++++++++++++-------------- 2 files changed, 30 insertions(+), 15 deletions(-) (limited to 'crates') diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml index 5b0a05dff..16fd56c7e 100644 --- a/crates/proc_macro_api/Cargo.toml +++ b/crates/proc_macro_api/Cargo.toml @@ -21,3 +21,4 @@ base_db = { path = "../base_db", version = "0.0.0" } stdx = { path = "../stdx", version = "0.0.0" } snap = "1" object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] } +memmap = "0.7.0" diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index cec854746..a58e39de0 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -9,15 +9,22 @@ pub mod msg; mod process; mod rpc; -use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, path::{Path, PathBuf}, sync::Arc}; - use base_db::{Env, ProcMacro}; +use std::{ + ffi::OsStr, + fs::File, + io::{self, Read}, + path::{Path, PathBuf}, + sync::Arc, +}; + use tt::{SmolStr, Subtree}; use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread}; pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind}; +use memmap::Mmap; use object::read::{File as BinaryFile, Object, ObjectSection}; use snap::read::FrameDecoder as SnapDecoder; @@ -110,13 +117,13 @@ impl ProcMacroClient { // This is used inside self.read_version() to locate the ".rustc" section // from a proc macro crate's binary file. - fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> &'a [u8] { + fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> { BinaryFile::parse(dylib_binary) - .unwrap() + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? .section_by_name(section_name) - .unwrap() + .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))? .data() - .unwrap() + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) } // Check the version of rustc that was used to compile a proc macro crate's @@ -138,10 +145,19 @@ impl ProcMacroClient { // * [some more bytes that we don really care but still there] :-) // Check this issue for more about the bytes layout: // https://github.com/rust-analyzer/rust-analyzer/issues/6174 - fn read_version(&self, dylib_path: &Path) -> String { - let dylib_binary = fsread(dylib_path).unwrap(); + #[allow(unused)] + fn read_version(&self, dylib_path: &Path) -> io::Result { + let dylib_file = File::open(dylib_path)?; + let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?; + + let dot_rustc = self.read_section(&dylib_mmaped, ".rustc")?; - let dot_rustc = self.read_section(&dylib_binary, ".rustc"); + let header = &dot_rustc[..8]; + const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5]; + // check if header is valid + if !(header == EXPECTED_HEADER) { + return Err(io::Error::new(io::ErrorKind::InvalidData, format!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,header))); + } let snappy_portion = &dot_rustc[8..]; @@ -154,14 +170,12 @@ impl ProcMacroClient { // so 13 bytes in total, and we should check the 13th byte // to know the length let mut bytes_before_version = [0u8; 13]; - snappy_decoder - .read_exact(&mut bytes_before_version) - .unwrap(); + snappy_decoder.read_exact(&mut bytes_before_version)?; let length = bytes_before_version[12]; // what? can't use -1 indexing? let mut version_string_utf8 = vec![0u8; length as usize]; - snappy_decoder.read_exact(&mut version_string_utf8).unwrap(); - let version_string = String::from_utf8(version_string_utf8).unwrap(); - version_string + snappy_decoder.read_exact(&mut version_string_utf8)?; + let version_string = String::from_utf8(version_string_utf8); + version_string.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) } } -- cgit v1.2.3 From c92db2abf989e76f6c6a4407c5ac3bfa7262c19a Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Wed, 23 Dec 2020 22:04:39 +0800 Subject: Update comment Co-authored-by: Jonas Schievink --- crates/proc_macro_api/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index a58e39de0..34a4e68ab 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -132,7 +132,7 @@ impl ProcMacroClient { // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes // * ff060000 734e6150 is followed, it's the snappy format magic bytes, // means bytes from here(including this sequence) are compressed in - // snappy compression format. Version info is here inside, so decompress + // snappy compression format. Version info is inside here, so decompress // this. // The bytes you get after decompressing the snappy format portion has // following layout: -- cgit v1.2.3 From a8f7326ee58185e3b2b95076b8542ef6afc80a5f Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Wed, 23 Dec 2020 22:19:27 +0800 Subject: Update condition check code style Co-authored-by: Jonas Schievink --- crates/proc_macro_api/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index 34a4e68ab..481fb6dee 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -155,7 +155,7 @@ impl ProcMacroClient { let header = &dot_rustc[..8]; const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5]; // check if header is valid - if !(header == EXPECTED_HEADER) { + if header != EXPECTED_HEADER { return Err(io::Error::new(io::ErrorKind::InvalidData, format!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,header))); } -- cgit v1.2.3 From 0669abda4aa2a544ad8ab465fba0853ff8379c23 Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Thu, 24 Dec 2020 23:00:59 +0800 Subject: Revise error message regarding metadata version MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Laurențiu Nicola --- crates/proc_macro_api/src/lib.rs | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) (limited to 'crates') diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index 481fb6dee..8f0f141f7 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -76,10 +76,7 @@ impl ProcMacroClient { args: impl IntoIterator>, ) -> io::Result { let (thread, process) = ProcMacroProcessSrv::run(process_path, args)?; - Ok(ProcMacroClient { - process: Arc::new(process), - thread, - }) + Ok(ProcMacroClient { process: Arc::new(process), thread }) } pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec { @@ -106,11 +103,7 @@ impl ProcMacroClient { dylib_path: dylib_path.into(), }); - ProcMacro { - name, - kind, - expander, - } + ProcMacro { name, kind, expander } }) .collect() } @@ -156,7 +149,10 @@ impl ProcMacroClient { const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5]; // check if header is valid if header != EXPECTED_HEADER { - return Err(io::Error::new(io::ErrorKind::InvalidData, format!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,header))); + return Err(io::Error::new( + io::ErrorKind::InvalidData, + format!("only metadata version 5 is supported, section header was: {:?}", header), + )); } let snappy_portion = &dot_rustc[8..]; -- cgit v1.2.3 From cc8c40480a34aa1d233d9a34b505bee16897ef54 Mon Sep 17 00:00:00 2001 From: Edwin Cheng Date: Thu, 4 Mar 2021 10:48:12 +0800 Subject: Print warning if proc-macro built by old rustc --- crates/proc_macro_api/src/lib.rs | 90 +++++------------------- crates/proc_macro_api/src/version.rs | 131 +++++++++++++++++++++++++++++++++++ 2 files changed, 148 insertions(+), 73 deletions(-) create mode 100644 crates/proc_macro_api/src/version.rs (limited to 'crates') diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index 8f0f141f7..941d0fe9e 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -8,12 +8,12 @@ pub mod msg; mod process; mod rpc; +mod version; use base_db::{Env, ProcMacro}; use std::{ ffi::OsStr, - fs::File, - io::{self, Read}, + io, path::{Path, PathBuf}, sync::Arc, }; @@ -24,10 +24,6 @@ use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread}; pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind}; -use memmap::Mmap; -use object::read::{File as BinaryFile, Object, ObjectSection}; -use snap::read::FrameDecoder as SnapDecoder; - #[derive(Debug, Clone)] struct ProcMacroProcessExpander { process: Arc, @@ -80,6 +76,21 @@ impl ProcMacroClient { } pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec { + match version::read_info(dylib_path) { + Ok(info) => { + if info.version.0 < 1 || info.version.1 < 47 { + eprintln!("proc-macro {} built by {:#?} is not supported by Rust Analyzer, please update your rust version.", dylib_path.to_string_lossy(), info); + } + } + Err(err) => { + eprintln!( + "proc-macro {} failed to find the given version. Reason: {}", + dylib_path.to_string_lossy(), + err + ); + } + } + let macros = match self.process.find_proc_macros(dylib_path) { Err(err) => { eprintln!("Failed to find proc macros. Error: {:#?}", err); @@ -107,71 +118,4 @@ impl ProcMacroClient { }) .collect() } - - // This is used inside self.read_version() to locate the ".rustc" section - // from a proc macro crate's binary file. - fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> { - BinaryFile::parse(dylib_binary) - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? - .section_by_name(section_name) - .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))? - .data() - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) - } - - // Check the version of rustc that was used to compile a proc macro crate's - // binary file. - // A proc macro crate binary's ".rustc" section has following byte layout: - // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes - // * ff060000 734e6150 is followed, it's the snappy format magic bytes, - // means bytes from here(including this sequence) are compressed in - // snappy compression format. Version info is inside here, so decompress - // this. - // The bytes you get after decompressing the snappy format portion has - // following layout: - // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) - // * [crate root bytes] next 4 bytes is to store crate root position, - // according to rustc's source code comment - // * [length byte] next 1 byte tells us how many bytes we should read next - // for the version string's utf8 bytes - // * [version string bytes encoded in utf8] <- GET THIS BOI - // * [some more bytes that we don really care but still there] :-) - // Check this issue for more about the bytes layout: - // https://github.com/rust-analyzer/rust-analyzer/issues/6174 - #[allow(unused)] - fn read_version(&self, dylib_path: &Path) -> io::Result { - let dylib_file = File::open(dylib_path)?; - let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?; - - let dot_rustc = self.read_section(&dylib_mmaped, ".rustc")?; - - let header = &dot_rustc[..8]; - const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5]; - // check if header is valid - if header != EXPECTED_HEADER { - return Err(io::Error::new( - io::ErrorKind::InvalidData, - format!("only metadata version 5 is supported, section header was: {:?}", header), - )); - } - - let snappy_portion = &dot_rustc[8..]; - - let mut snappy_decoder = SnapDecoder::new(snappy_portion); - - // the bytes before version string bytes, so this basically is: - // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5] - // 4 bytes for [crate root bytes] - // 1 byte for length of version string - // so 13 bytes in total, and we should check the 13th byte - // to know the length - let mut bytes_before_version = [0u8; 13]; - snappy_decoder.read_exact(&mut bytes_before_version)?; - let length = bytes_before_version[12]; // what? can't use -1 indexing? - - let mut version_string_utf8 = vec![0u8; length as usize]; - snappy_decoder.read_exact(&mut version_string_utf8)?; - let version_string = String::from_utf8(version_string_utf8); - version_string.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) - } } diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs new file mode 100644 index 000000000..80cd183a0 --- /dev/null +++ b/crates/proc_macro_api/src/version.rs @@ -0,0 +1,131 @@ +//! Reading proc-macro rustc version information from binary data + +use std::{ + fs::File, + io::{self, Read}, + path::Path, +}; + +use memmap::Mmap; +use object::read::{File as BinaryFile, Object, ObjectSection}; +use snap::read::FrameDecoder as SnapDecoder; + +#[derive(Debug)] +pub(crate) struct RustCInfo { + pub(crate) version: (usize, usize, usize), + pub(crate) channel: String, + pub(crate) commit: String, + pub(crate) date: String, +} + +pub(crate) fn read_info(dylib_path: &Path) -> io::Result { + macro_rules! err { + ($e:literal) => { + io::Error::new(io::ErrorKind::InvalidData, $e) + }; + } + + let ver_str = read_version(dylib_path)?; + let mut items = ver_str.split_whitespace(); + let tag = items.next().ok_or(err!("version format error"))?; + if tag != "rustc" { + return Err(err!("version format error (No rustc tag)")); + } + + let version_part = items.next().ok_or(err!("no version string"))?; + let mut version_parts = version_part.split("-"); + let version = version_parts.next().ok_or(err!("no version"))?; + let channel = version_parts.next().unwrap_or_default().to_string(); + + let commit = items.next().ok_or(err!("no commit info"))?; + // remove ( + if commit.len() == 0 { + return Err(err!("commit format error")); + } + let commit = commit[1..].to_string(); + let date = items.next().ok_or(err!("no date info"))?; + // remove ) + if date.len() == 0 { + return Err(err!("date format error")); + } + let date = date[0..date.len() - 2].to_string(); + + let version_numbers = version + .split(".") + .map(|it| it.parse::()) + .collect::, _>>() + .map_err(|_| err!("version number error"))?; + + if version_numbers.len() != 3 { + return Err(err!("version number format error")); + } + let version = (version_numbers[0], version_numbers[1], version_numbers[2]); + + Ok(RustCInfo { version, channel, commit, date }) +} + +// This is used inside read_version() to locate the ".rustc" section +// from a proc macro crate's binary file. +fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> { + BinaryFile::parse(dylib_binary) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + .section_by_name(section_name) + .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))? + .data() + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) +} + +// Check the version of rustc that was used to compile a proc macro crate's +// binary file. +// A proc macro crate binary's ".rustc" section has following byte layout: +// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes +// * ff060000 734e6150 is followed, it's the snappy format magic bytes, +// means bytes from here(including this sequence) are compressed in +// snappy compression format. Version info is inside here, so decompress +// this. +// The bytes you get after decompressing the snappy format portion has +// following layout: +// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) +// * [crate root bytes] next 4 bytes is to store crate root position, +// according to rustc's source code comment +// * [length byte] next 1 byte tells us how many bytes we should read next +// for the version string's utf8 bytes +// * [version string bytes encoded in utf8] <- GET THIS BOI +// * [some more bytes that we don really care but still there] :-) +// Check this issue for more about the bytes layout: +// https://github.com/rust-analyzer/rust-analyzer/issues/6174 +fn read_version(dylib_path: &Path) -> io::Result { + let dylib_file = File::open(dylib_path)?; + let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?; + + let dot_rustc = read_section(&dylib_mmaped, ".rustc")?; + + let header = &dot_rustc[..8]; + const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5]; + // check if header is valid + if header != EXPECTED_HEADER { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + format!("only metadata version 5 is supported, section header was: {:?}", header), + )); + } + + let snappy_portion = &dot_rustc[8..]; + + let mut snappy_decoder = SnapDecoder::new(snappy_portion); + + // the bytes before version string bytes, so this basically is: + // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5] + // 4 bytes for [crate root bytes] + // 1 byte for length of version string + // so 13 bytes in total, and we should check the 13th byte + // to know the length + let mut bytes_before_version = [0u8; 13]; + snappy_decoder.read_exact(&mut bytes_before_version)?; + let length = bytes_before_version[12]; // what? can't use -1 indexing? + + let mut version_string_utf8 = vec![0u8; length as usize]; + snappy_decoder.read_exact(&mut version_string_utf8)?; + let version_string = String::from_utf8(version_string_utf8); + version_string.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) +} -- cgit v1.2.3 From ad34e79bb9818cc9bf3d0cf746bd052a67c7bab9 Mon Sep 17 00:00:00 2001 From: Edwin Cheng Date: Wed, 10 Mar 2021 04:54:31 +0800 Subject: use doc-comments --- crates/proc_macro_api/src/version.rs | 43 ++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 21 deletions(-) (limited to 'crates') diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs index 80cd183a0..11a7fb59a 100644 --- a/crates/proc_macro_api/src/version.rs +++ b/crates/proc_macro_api/src/version.rs @@ -64,8 +64,8 @@ pub(crate) fn read_info(dylib_path: &Path) -> io::Result { Ok(RustCInfo { version, channel, commit, date }) } -// This is used inside read_version() to locate the ".rustc" section -// from a proc macro crate's binary file. +/// This is used inside read_version() to locate the ".rustc" section +/// from a proc macro crate's binary file. fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> { BinaryFile::parse(dylib_binary) .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? @@ -75,25 +75,26 @@ fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&' .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)) } -// Check the version of rustc that was used to compile a proc macro crate's -// binary file. -// A proc macro crate binary's ".rustc" section has following byte layout: -// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes -// * ff060000 734e6150 is followed, it's the snappy format magic bytes, -// means bytes from here(including this sequence) are compressed in -// snappy compression format. Version info is inside here, so decompress -// this. -// The bytes you get after decompressing the snappy format portion has -// following layout: -// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) -// * [crate root bytes] next 4 bytes is to store crate root position, -// according to rustc's source code comment -// * [length byte] next 1 byte tells us how many bytes we should read next -// for the version string's utf8 bytes -// * [version string bytes encoded in utf8] <- GET THIS BOI -// * [some more bytes that we don really care but still there] :-) -// Check this issue for more about the bytes layout: -// https://github.com/rust-analyzer/rust-analyzer/issues/6174 +/// Check the version of rustc that was used to compile a proc macro crate's +/// +/// binary file. +/// A proc macro crate binary's ".rustc" section has following byte layout: +/// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes +/// * ff060000 734e6150 is followed, it's the snappy format magic bytes, +/// means bytes from here(including this sequence) are compressed in +/// snappy compression format. Version info is inside here, so decompress +/// this. +/// The bytes you get after decompressing the snappy format portion has +/// following layout: +/// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) +/// * [crate root bytes] next 4 bytes is to store crate root position, +/// according to rustc's source code comment +/// * [length byte] next 1 byte tells us how many bytes we should read next +/// for the version string's utf8 bytes +/// * [version string bytes encoded in utf8] <- GET THIS BOI +/// * [some more bytes that we don really care but still there] :-) +/// Check this issue for more about the bytes layout: +/// https://github.com/rust-analyzer/rust-analyzer/issues/6174 fn read_version(dylib_path: &Path) -> io::Result { let dylib_file = File::open(dylib_path)?; let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?; -- cgit v1.2.3