---

yaml
---
r: 161774
b: refs/heads/master
c: 5263600
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 602fc781ff0990b7f94851e210c6a4a516c80935
+refs/heads/master: 52636007ce40da67998276c0671c6345512c3b58
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6

trunk/src/etc/rustup.sh

@@ -188,7 +188,7 @@ flag() {
      fi
 }
 
-validate_opt () {
+validate_opt() {
     for arg in $CFG_ARGS
     do
         isArgValid=0
@@ -230,6 +230,7 @@ validate_opt () {
 }
 
 probe_need CFG_CURL  curl
+probe_need CFG_TAR   tar
 
 CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
 CFG_SELF="$0"
@@ -388,89 +389,109 @@ esac
 
 msg "host triple: ${HOST_TRIPLE}"
 
-PACKAGE_NAME=rust-nightly
-PACKAGE_NAME_AND_TRIPLE="${PACKAGE_NAME}-${HOST_TRIPLE}"
-TARBALL_NAME="${PACKAGE_NAME_AND_TRIPLE}.tar.gz"
-REMOTE_TARBALL="https://static.rust-lang.org/dist/${TARBALL_NAME}"
-TMP_DIR="./rustup-tmp-install"
-LOCAL_TARBALL="${TMP_DIR}/${TARBALL_NAME}"
-LOCAL_INSTALL_DIR="${TMP_DIR}/${PACKAGE_NAME_AND_TRIPLE}"
-LOCAL_INSTALL_SCRIPT="${LOCAL_INSTALL_DIR}/install.sh"
+CFG_INSTALL_FLAGS=""
+if [ -n "${CFG_UNINSTALL}" ]
+then
+    CFG_INSTALL_FLAGS="${CFG_INSTALL_FLAGS} --uninstall"
+fi
+
+if [ -n "${CFG_PREFIX}" ]
+then
+    CFG_INSTALL_FLAGS="${CFG_INSTALL_FLAGS} --prefix=${CFG_PREFIX}"
+fi
+
+CFG_TMP_DIR="./rustup-tmp-install"
 
+RUST_URL="https://static.rust-lang.org/dist"
+RUST_PACKAGE_NAME=rust-nightly
+RUST_PACKAGE_NAME_AND_TRIPLE="${RUST_PACKAGE_NAME}-${HOST_TRIPLE}"
+RUST_TARBALL_NAME="${RUST_PACKAGE_NAME_AND_TRIPLE}.tar.gz"
+RUST_LOCAL_INSTALL_DIR="${CFG_TMP_DIR}/${RUST_PACKAGE_NAME_AND_TRIPLE}"
+RUST_LOCAL_INSTALL_SCRIPT="${RUST_LOCAL_INSTALL_DIR}/install.sh"
+
+CARGO_URL="https://static.rust-lang.org/cargo-dist"
 CARGO_PACKAGE_NAME=cargo-nightly
 CARGO_PACKAGE_NAME_AND_TRIPLE="${CARGO_PACKAGE_NAME}-${HOST_TRIPLE}"
 CARGO_TARBALL_NAME="${CARGO_PACKAGE_NAME_AND_TRIPLE}.tar.gz"
-CARGO_REMOTE_TARBALL="https://static.rust-lang.org/cargo-dist/${CARGO_TARBALL_NAME}"
-CARGO_LOCAL_TARBALL="${TMP_DIR}/${CARGO_TARBALL_NAME}"
-CARGO_LOCAL_INSTALL_DIR="${TMP_DIR}/${CARGO_PACKAGE_NAME_AND_TRIPLE}"
+CARGO_LOCAL_INSTALL_DIR="${CFG_TMP_DIR}/${CARGO_PACKAGE_NAME_AND_TRIPLE}"
 CARGO_LOCAL_INSTALL_SCRIPT="${CARGO_LOCAL_INSTALL_DIR}/install.sh"
 
-rm -Rf "${TMP_DIR}"
-need_ok "failed to remove temporary installation directory"
+# Fetch the package.
+download_package() {
+    remote_tarball="$1"
+    local_tarball="$2"
 
-mkdir -p "${TMP_DIR}"
-need_ok "failed to create create temporary installation directory"
+    msg "Downloading ${remote_tarball} to ${local_tarball}"
 
-msg "downloading rust installer"
-"${CFG_CURL}" "${REMOTE_TARBALL}" > "${LOCAL_TARBALL}"
-if [ $? -ne 0 ]
-then
-        rm -Rf "${TMP_DIR}"
-        err "failed to download installer"
-fi
+    mkdir -p "${CFG_TMP_DIR}"
+    need_ok "failed to create create download directory"
 
-if [ -z "${CFG_DISABLE_CARGO}" ]; then
-    msg "downloading cargo installer"
-    "${CFG_CURL}" "${CARGO_REMOTE_TARBALL}" > "${CARGO_LOCAL_TARBALL}"
+    "${CFG_CURL}" -f -o "${local_tarball}" "${remote_tarball}"
     if [ $? -ne 0 ]
     then
-            rm -Rf "${TMP_DIR}"
-            err "failed to download cargo installer"
+        rm -Rf "${CFG_TMP_DIR}"
+        err "failed to download installer"
     fi
-fi
+}
 
+# Wrap all the commands needed to install a package.
+install_package() {
+    tarball_name="$1"
+    install_script="$2"
 
-(cd "${TMP_DIR}" && tar xzf "${TARBALL_NAME}")
-if [ $? -ne 0 ]
-then
-        rm -Rf "${TMP_DIR}"
+    msg "Extracting ${tarball_name}"
+    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xvf "${tarball_name}")
+    if [ $? -ne 0 ]; then
+        rm -Rf "${CFG_TMP_DIR}"
         err "failed to unpack installer"
-fi
-
-MAYBE_UNINSTALL=
-if [ -n "${CFG_UNINSTALL}" ]
-then
-        MAYBE_UNINSTALL="--uninstall"
-fi
-
-MAYBE_PREFIX=
-if [ -n "${CFG_PREFIX}" ]
-then
-        MAYBE_PREFIX="--prefix=${CFG_PREFIX}"
-fi
-
-sh "${LOCAL_INSTALL_SCRIPT}" "${MAYBE_UNINSTALL}" "${MAYBE_PREFIX}"
-if [ $? -ne 0 ]
-then
-        rm -Rf "${TMP_DIR}"
-        err "failed to install Rust"
-fi
+    fi
 
-if [ -z "${CFG_DISABLE_CARGO}" ]; then
-    (cd "${TMP_DIR}" && tar xzf "${CARGO_TARBALL_NAME}")
+    sh "${install_script}" "${CFG_INSTALL_FLAGS}"
     if [ $? -ne 0 ]
     then
-            rm -Rf "${TMP_DIR}"
-            err "failed to unpack cargo installer"
+        rm -Rf "${CFG_TMP_DIR}"
+        err "failed to install Rust"
     fi
+}
 
-    sh "${CARGO_LOCAL_INSTALL_SCRIPT}" "${MAYBE_UNINSTALL}" "${MAYBE_PREFIX}"
-    if [ $? -ne 0 ]
-    then
-            rm -Rf "${TMP_DIR}"
-            err "failed to install Cargo"
+# It's possible that curl could be interrupted partway though downloading
+# `rustup.sh`, truncating the file. This could be especially bad if we were in
+# the middle of a line that would run "rm -rf ". To protect against this, we
+# wrap up the `rustup.sh` destructive functionality in this helper function,
+# which we call as the last thing we do. This means we will not do anything
+# unless we have the entire file downloaded.
+install_packages() {
+    rm -Rf "${CFG_TMP_DIR}"
+    need_ok "failed to remove temporary installation directory"
+
+    mkdir -p "${CFG_TMP_DIR}"
+    need_ok "failed to create create temporary installation directory"
+
+    RUST_LOCAL_TARBALL="${CFG_TMP_DIR}/${RUST_TARBALL_NAME}"
+    CARGO_LOCAL_TARBALL="${CFG_TMP_DIR}/${CARGO_TARBALL_NAME}"
+
+    download_package \
+        "${RUST_URL}/${RUST_TARBALL_NAME}" \
+        "${RUST_LOCAL_TARBALL}"
+
+    if [ -z "${CFG_DISABLE_CARGO}" ]; then
+        download_package \
+            "${CARGO_URL}/${CARGO_TARBALL_NAME}" \
+            "${CARGO_LOCAL_TARBALL}"
     fi
-fi
 
-rm -Rf "${TMP_DIR}"
-need_ok "couldn't rm temporary installation directory"
+    install_package \
+        "${RUST_TARBALL_NAME}" \
+        "${RUST_LOCAL_INSTALL_SCRIPT}"
+
+    if [ -z "${CFG_DISABLE_CARGO}" ]; then
+        install_package \
+            "${CARGO_TARBALL_NAME}" \
+            "${CARGO_LOCAL_INSTALL_SCRIPT}"
+    fi
+
+    rm -Rf "${CFG_TMP_DIR}"
+    need_ok "couldn't rm temporary installation directory"
+}
+
+install_packages

trunk/src/libcore/result.rs

@@ -444,15 +444,14 @@ impl<T, E> Result<T, E> {
     /// ignoring I/O and parse errors:
     ///
     /// ```
-    /// use std::io::{BufReader, IoResult};
+    /// use std::io::IoResult;
     ///
-    /// let buffer = "1\n2\n3\n4\n";
-    /// let mut reader = BufReader::new(buffer.as_bytes());
+    /// let mut buffer = &mut b"1\n2\n3\n4\n";
     ///
     /// let mut sum = 0;
     ///
-    /// while !reader.eof() {
-    ///     let line: IoResult<String> = reader.read_line();
+    /// while !buffer.is_empty() {
+    ///     let line: IoResult<String> = buffer.read_line();
     ///     // Convert the string line to a number using `map` and `from_str`
     ///     let val: IoResult<int> = line.map(|line| {
     ///         from_str::<int>(line.as_slice().trim_right()).unwrap_or(0)

trunk/src/libgraphviz/lib.rs

@@ -547,7 +547,7 @@ mod tests {
     use self::NodeLabels::*;
     use super::{Id, LabelText, LabelStr, EscStr, Labeller};
     use super::{Nodes, Edges, GraphWalk, render};
-    use std::io::{BufReader, IoResult};
+    use std::io::IoResult;
     use std::str;
 
     /// each node is an index in a vector in the graph.
@@ -698,8 +698,7 @@ mod tests {
     fn test_input(g: LabelledGraph) -> IoResult<String> {
         let mut writer = Vec::new();
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer[]);
-        r.read_to_string()
+        (&mut writer.as_slice()).read_to_string()
     }
 
     // All of the tests use raw-strings as the format for the expected outputs,
@@ -811,8 +810,7 @@ r#"digraph hasse_diagram {
                  edge(1, 3, ";"),    edge(2, 3, ";"   )));
 
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer[]);
-        let r = r.read_to_string();
+        let r = (&mut writer.as_slice()).read_to_string();
 
         assert_eq!(r.unwrap().as_slice(),
 r#"digraph syntax_tree {

trunk/src/libstd/io/buffered.rs

@@ -406,7 +406,7 @@ mod test {
     use prelude::*;
     use super::*;
     use super::super::{IoResult, EndOfFile};
-    use super::super::mem::{MemReader, BufReader};
+    use super::super::mem::MemReader;
     use self::test::Bencher;
     use str::StrPrelude;
 
@@ -626,14 +626,14 @@ mod test {
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
+        let mut reader = BufferedReader::with_capacity(1, buf[]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
+        let mut reader = BufferedReader::with_capacity(1, buf[]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));

trunk/src/libstd/io/fs.rs

@@ -53,7 +53,8 @@
 use clone::Clone;
 use io::standard_error;
 use io::{FilePermission, Write, Open, FileAccess, FileMode, FileType};
-use io::{IoResult, IoError, FileStat, SeekStyle, Seek, Writer, Reader};
+use io::{IoResult, IoError, InvalidInput};
+use io::{FileStat, SeekStyle, Seek, Writer, Reader};
 use io::{Read, Truncate, ReadWrite, Append};
 use io::UpdateIoError;
 use io;
@@ -134,13 +135,26 @@ impl File {
     pub fn open_mode(path: &Path,
                      mode: FileMode,
                      access: FileAccess) -> IoResult<File> {
-        fs_imp::open(path, mode, access).map(|fd| {
-            File {
-                path: path.clone(),
-                fd: fd,
-                last_nread: -1
+        fs_imp::open(path, mode, access).and_then(|fd| {
+            // On *BSD systems, we can open a directory as a file and read from it:
+            // fd=open("/tmp", O_RDONLY); read(fd, buf, N);
+            // due to an old tradition before the introduction of opendir(3).
+            // We explicitly reject it because there are few use cases.
+            if cfg!(not(any(windows, target_os = "linux", target_os = "android"))) &&
+               try!(fd.fstat()).kind == FileType::Directory {
+                Err(IoError {
+                    kind: InvalidInput,
+                    desc: "is a directory",
+                    detail: None
+                })
+            } else {
+                Ok(File {
+                    path: path.clone(),
+                    fd: fd,
+                    last_nread: -1
+                })
             }
-        }).update_err("couldn't open file", |e| {
+        }).update_err("couldn't open path as file", |e| {
             format!("{}; path={}; mode={}; access={}", e, path.display(),
                 mode_string(mode), access_string(access))
         })
@@ -237,7 +251,7 @@ impl File {
     }
 
     /// Queries information about the underlying file.
-    pub fn stat(&mut self) -> IoResult<FileStat> {
+    pub fn stat(&self) -> IoResult<FileStat> {
         self.fd.fstat()
             .update_err("couldn't fstat file", |e|
                 format!("{}; path={}", e, self.path.display()))
@@ -886,7 +900,7 @@ mod test {
         let filename = &tmpdir.join("file_that_does_not_exist.txt");
         let result = File::open_mode(filename, Open, Read);
 
-        error!(result, "couldn't open file");
+        error!(result, "couldn't open path as file");
         if cfg!(unix) {
             error!(result, "no such file or directory");
         }