library/std/src/io/error.rs

   1 #[cfg(test)]
   2 mod tests;
   3
   4 #[cfg(target_pointer_width = "64")]
   5 mod repr_bitpacked;
   6 #[cfg(target_pointer_width = "64")]
   7 use repr_bitpacked::Repr;
   8
   9 #[cfg(not(target_pointer_width = "64"))]
  10 mod repr_unpacked;
  11 #[cfg(not(target_pointer_width = "64"))]
  12 use repr_unpacked::Repr;
  13
  14 use crate::convert::From;
  15 use crate::error;
  16 use crate::fmt;
  17 use crate::result;
  18 use crate::sys;
  19
  20 /// A specialized [`Result`] type for I/O operations.
  21 ///
  22 /// This type is broadly used across [`std::io`] for any operation which may
  23 /// produce an error.
  24 ///
  25 /// This typedef is generally used to avoid writing out [`io::Error`] directly and
  26 /// is otherwise a direct mapping to [`Result`].
  27 ///
  28 /// While usual Rust style is to import types directly, aliases of [`Result`]
  29 /// often are not, to make it easier to distinguish between them. [`Result`] is
  30 /// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
  31 /// will generally use `io::Result` instead of shadowing the [prelude]'s import
  32 /// of [`std::result::Result`][`Result`].
  33 ///
  34 /// [`std::io`]: crate::io
  35 /// [`io::Error`]: Error
  36 /// [`Result`]: crate::result::Result
  37 /// [prelude]: crate::prelude
  38 ///
  39 /// # Examples
  40 ///
  41 /// A convenience function that bubbles an `io::Result` to its caller:
  42 ///
  43 /// ```
  44 /// use std::io;
  45 ///
  46 /// fn get_string() -> io::Result<String> {
  47 ///     let mut buffer = String::new();
  48 ///
  49 ///     io::stdin().read_line(&mut buffer)?;
  50 ///
  51 ///     Ok(buffer)
  52 /// }
  53 /// ```
  54 #[stable(feature = "rust1", since = "1.0.0")]
  55 pub type Result<T> = result::Result<T, Error>;
  56
  57 /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
  58 /// associated traits.
  59 ///
  60 /// Errors mostly originate from the underlying OS, but custom instances of
  61 /// `Error` can be created with crafted error messages and a particular value of
  62 /// [`ErrorKind`].
  63 ///
  64 /// [`Read`]: crate::io::Read
  65 /// [`Write`]: crate::io::Write
  66 /// [`Seek`]: crate::io::Seek
  67 #[stable(feature = "rust1", since = "1.0.0")]
  68 pub struct Error {
  69     repr: Repr,
  70 }
  71
  72 #[stable(feature = "rust1", since = "1.0.0")]
  73 impl fmt::Debug for Error {
  74     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  75         fmt::Debug::fmt(&self.repr, f)
  76     }
  77 }
  78
  79 #[stable(feature = "rust1", since = "1.0.0")]
  80 impl From<alloc::ffi::NulError> for Error {
  81     /// Converts a [`alloc::ffi::NulError`] into a [`Error`].
  82     fn from(_: alloc::ffi::NulError) -> Error {
  83         const_io_error!(ErrorKind::InvalidInput, "data provided contains a nul byte")
  84     }
  85 }
  86
  87 // Only derive debug in tests, to make sure it
  88 // doesn't accidentally get printed.
  89 #[cfg_attr(test, derive(Debug))]
  90 enum ErrorData<C> {
  91     Os(i32),
  92     Simple(ErrorKind),
  93     SimpleMessage(&'static SimpleMessage),
  94     Custom(C),
  95 }
  96
  97 // `#[repr(align(4))]` is probably redundant, it should have that value or
  98 // higher already. We include it just because repr_bitpacked.rs's encoding
  99 // requires an alignment >= 4 (note that `#[repr(align)]` will not reduce the
 100 // alignment required by the struct, only increase it).
 101 //
 102 // If we add more variants to ErrorData, this can be increased to 8, but it
 103 // should probably be behind `#[cfg_attr(target_pointer_width = "64", ...)]` or
 104 // whatever cfg we're using to enable the `repr_bitpacked` code, since only the
 105 // that version needs the alignment, and 8 is higher than the alignment we'll
 106 // have on 32 bit platforms.
 107 //
 108 // (For the sake of being explicit: the alignment requirement here only matters
 109 // if `error/repr_bitpacked.rs` is in use — for the unpacked repr it doesn't
 110 // matter at all)
 111 #[repr(align(4))]
 112 #[derive(Debug)]
 113 pub(crate) struct SimpleMessage {
 114     kind: ErrorKind,
 115     message: &'static str,
 116 }
 117
 118 impl SimpleMessage {
 119     pub(crate) const fn new(kind: ErrorKind, message: &'static str) -> Self {
 120         Self { kind, message }
 121     }
 122 }
 123
 124 /// Create and return an `io::Error` for a given `ErrorKind` and constant
 125 /// message. This doesn't allocate.
 126 pub(crate) macro const_io_error($kind:expr, $message:expr $(,)?) {
 127     $crate::io::error::Error::from_static_message({
 128         const MESSAGE_DATA: $crate::io::error::SimpleMessage =
 129             $crate::io::error::SimpleMessage::new($kind, $message);
 130         &MESSAGE_DATA
 131     })
 132 }
 133
 134 // As with `SimpleMessage`: `#[repr(align(4))]` here is just because
 135 // repr_bitpacked's encoding requires it. In practice it almost certainly be
 136 // already be this high or higher.
 137 #[derive(Debug)]
 138 #[repr(align(4))]
 139 struct Custom {
 140     kind: ErrorKind,
 141     error: Box<dyn error::Error + Send + Sync>,
 142 }
 143
 144 /// A list specifying general categories of I/O error.
 145 ///
 146 /// This list is intended to grow over time and it is not recommended to
 147 /// exhaustively match against it.
 148 ///
 149 /// It is used with the [`io::Error`] type.
 150 ///
 151 /// [`io::Error`]: Error
 152 ///
 153 /// # Handling errors and matching on `ErrorKind`
 154 ///
 155 /// In application code, use `match` for the `ErrorKind` values you are
 156 /// expecting; use `_` to match "all other errors".
 157 ///
 158 /// In comprehensive and thorough tests that want to verify that a test doesn't
 159 /// return any known incorrect error kind, you may want to cut-and-paste the
 160 /// current full list of errors from here into your test code, and then match
 161 /// `_` as the correct case. This seems counterintuitive, but it will make your
 162 /// tests more robust. In particular, if you want to verify that your code does
 163 /// produce an unrecognized error kind, the robust solution is to check for all
 164 /// the recognized error kinds and fail in those cases.
 165 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 166 #[stable(feature = "rust1", since = "1.0.0")]
 167 #[allow(deprecated)]
 168 #[non_exhaustive]
 169 pub enum ErrorKind {
 170     /// An entity was not found, often a file.
 171     #[stable(feature = "rust1", since = "1.0.0")]
 172     NotFound,
 173     /// The operation lacked the necessary privileges to complete.
 174     #[stable(feature = "rust1", since = "1.0.0")]
 175     PermissionDenied,
 176     /// The connection was refused by the remote server.
 177     #[stable(feature = "rust1", since = "1.0.0")]
 178     ConnectionRefused,
 179     /// The connection was reset by the remote server.
 180     #[stable(feature = "rust1", since = "1.0.0")]
 181     ConnectionReset,
 182     /// The remote host is not reachable.
 183     #[unstable(feature = "io_error_more", issue = "86442")]
 184     HostUnreachable,
 185     /// The network containing the remote host is not reachable.
 186     #[unstable(feature = "io_error_more", issue = "86442")]
 187     NetworkUnreachable,
 188     /// The connection was aborted (terminated) by the remote server.
 189     #[stable(feature = "rust1", since = "1.0.0")]
 190     ConnectionAborted,
 191     /// The network operation failed because it was not connected yet.
 192     #[stable(feature = "rust1", since = "1.0.0")]
 193     NotConnected,
 194     /// A socket address could not be bound because the address is already in
 195     /// use elsewhere.
 196     #[stable(feature = "rust1", since = "1.0.0")]
 197     AddrInUse,
 198     /// A nonexistent interface was requested or the requested address was not
 199     /// local.
 200     #[stable(feature = "rust1", since = "1.0.0")]
 201     AddrNotAvailable,
 202     /// The system's networking is down.
 203     #[unstable(feature = "io_error_more", issue = "86442")]
 204     NetworkDown,
 205     /// The operation failed because a pipe was closed.
 206     #[stable(feature = "rust1", since = "1.0.0")]
 207     BrokenPipe,
 208     /// An entity already exists, often a file.
 209     #[stable(feature = "rust1", since = "1.0.0")]
 210     AlreadyExists,
 211     /// The operation needs to block to complete, but the blocking operation was
 212     /// requested to not occur.
 213     #[stable(feature = "rust1", since = "1.0.0")]
 214     WouldBlock,
 215     /// A filesystem object is, unexpectedly, not a directory.
 216     ///
 217     /// For example, a filesystem path was specified where one of the intermediate directory
 218     /// components was, in fact, a plain file.
 219     #[unstable(feature = "io_error_more", issue = "86442")]
 220     NotADirectory,
 221     /// The filesystem object is, unexpectedly, a directory.
 222     ///
 223     /// A directory was specified when a non-directory was expected.
 224     #[unstable(feature = "io_error_more", issue = "86442")]
 225     IsADirectory,
 226     /// A non-empty directory was specified where an empty directory was expected.
 227     #[unstable(feature = "io_error_more", issue = "86442")]
 228     DirectoryNotEmpty,
 229     /// The filesystem or storage medium is read-only, but a write operation was attempted.
 230     #[unstable(feature = "io_error_more", issue = "86442")]
 231     ReadOnlyFilesystem,
 232     /// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links.
 233     ///
 234     /// There was a loop (or excessively long chain) resolving a filesystem object
 235     /// or file IO object.
 236     ///
 237     /// On Unix this is usually the result of a symbolic link loop; or, of exceeding the
 238     /// system-specific limit on the depth of symlink traversal.
 239     #[unstable(feature = "io_error_more", issue = "86442")]
 240     FilesystemLoop,
 241     /// Stale network file handle.
 242     ///
 243     /// With some network filesystems, notably NFS, an open file (or directory) can be invalidated
 244     /// by problems with the network or server.
 245     #[unstable(feature = "io_error_more", issue = "86442")]
 246     StaleNetworkFileHandle,
 247     /// A parameter was incorrect.
 248     #[stable(feature = "rust1", since = "1.0.0")]
 249     InvalidInput,
 250     /// Data not valid for the operation were encountered.
 251     ///
 252     /// Unlike [`InvalidInput`], this typically means that the operation
 253     /// parameters were valid, however the error was caused by malformed
 254     /// input data.
 255     ///
 256     /// For example, a function that reads a file into a string will error with
 257     /// `InvalidData` if the file's contents are not valid UTF-8.
 258     ///
 259     /// [`InvalidInput`]: ErrorKind::InvalidInput
 260     #[stable(feature = "io_invalid_data", since = "1.2.0")]
 261     InvalidData,
 262     /// The I/O operation's timeout expired, causing it to be canceled.
 263     #[stable(feature = "rust1", since = "1.0.0")]
 264     TimedOut,
 265     /// An error returned when an operation could not be completed because a
 266     /// call to [`write`] returned [`Ok(0)`].
 267     ///
 268     /// This typically means that an operation could only succeed if it wrote a
 269     /// particular number of bytes but only a smaller number of bytes could be
 270     /// written.
 271     ///
 272     /// [`write`]: crate::io::Write::write
 273     /// [`Ok(0)`]: Ok
 274     #[stable(feature = "rust1", since = "1.0.0")]
 275     WriteZero,
 276     /// The underlying storage (typically, a filesystem) is full.
 277     ///
 278     /// This does not include out of quota errors.
 279     #[unstable(feature = "io_error_more", issue = "86442")]
 280     StorageFull,
 281     /// Seek on unseekable file.
 282     ///
 283     /// Seeking was attempted on an open file handle which is not suitable for seeking - for
 284     /// example, on Unix, a named pipe opened with `File::open`.
 285     #[unstable(feature = "io_error_more", issue = "86442")]
 286     NotSeekable,
 287     /// Filesystem quota was exceeded.
 288     #[unstable(feature = "io_error_more", issue = "86442")]
 289     FilesystemQuotaExceeded,
 290     /// File larger than allowed or supported.
 291     ///
 292     /// This might arise from a hard limit of the underlying filesystem or file access API, or from
 293     /// an administratively imposed resource limitation.  Simple disk full, and out of quota, have
 294     /// their own errors.
 295     #[unstable(feature = "io_error_more", issue = "86442")]
 296     FileTooLarge,
 297     /// Resource is busy.
 298     #[unstable(feature = "io_error_more", issue = "86442")]
 299     ResourceBusy,
 300     /// Executable file is busy.
 301     ///
 302     /// An attempt was made to write to a file which is also in use as a running program.  (Not all
 303     /// operating systems detect this situation.)
 304     #[unstable(feature = "io_error_more", issue = "86442")]
 305     ExecutableFileBusy,
 306     /// Deadlock (avoided).
 307     ///
 308     /// A file locking operation would result in deadlock.  This situation is typically detected, if
 309     /// at all, on a best-effort basis.
 310     #[unstable(feature = "io_error_more", issue = "86442")]
 311     Deadlock,
 312     /// Cross-device or cross-filesystem (hard) link or rename.
 313     #[unstable(feature = "io_error_more", issue = "86442")]
 314     CrossesDevices,
 315     /// Too many (hard) links to the same filesystem object.
 316     ///
 317     /// The filesystem does not support making so many hardlinks to the same file.
 318     #[unstable(feature = "io_error_more", issue = "86442")]
 319     TooManyLinks,
 320     /// A filename was invalid.
 321     ///
 322     /// This error can also cause if it exceeded the filename length limit.
 323     #[unstable(feature = "io_error_more", issue = "86442")]
 324     InvalidFilename,
 325     /// Program argument list too long.
 326     ///
 327     /// When trying to run an external program, a system or process limit on the size of the
 328     /// arguments would have been exceeded.
 329     #[unstable(feature = "io_error_more", issue = "86442")]
 330     ArgumentListTooLong,
 331     /// This operation was interrupted.
 332     ///
 333     /// Interrupted operations can typically be retried.
 334     #[stable(feature = "rust1", since = "1.0.0")]
 335     Interrupted,
 336
 337     /// This operation is unsupported on this platform.
 338     ///
 339     /// This means that the operation can never succeed.
 340     #[stable(feature = "unsupported_error", since = "1.53.0")]
 341     Unsupported,
 342
 343     // ErrorKinds which are primarily categorisations for OS error
 344     // codes should be added above.
 345     //
 346     /// An error returned when an operation could not be completed because an
 347     /// "end of file" was reached prematurely.
 348     ///
 349     /// This typically means that an operation could only succeed if it read a
 350     /// particular number of bytes but only a smaller number of bytes could be
 351     /// read.
 352     #[stable(feature = "read_exact", since = "1.6.0")]
 353     UnexpectedEof,
 354
 355     /// An operation could not be completed, because it failed
 356     /// to allocate enough memory.
 357     #[stable(feature = "out_of_memory_error", since = "1.54.0")]
 358     OutOfMemory,
 359
 360     // "Unusual" error kinds which do not correspond simply to (sets
 361     // of) OS error codes, should be added just above this comment.
 362     // `Other` and `Uncategorised` should remain at the end:
 363     //
 364     /// A custom error that does not fall under any other I/O error kind.
 365     ///
 366     /// This can be used to construct your own [`Error`]s that do not match any
 367     /// [`ErrorKind`].
 368     ///
 369     /// This [`ErrorKind`] is not used by the standard library.
 370     ///
 371     /// Errors from the standard library that do not fall under any of the I/O
 372     /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern.
 373     /// New [`ErrorKind`]s might be added in the future for some of those.
 374     #[stable(feature = "rust1", since = "1.0.0")]
 375     Other,
 376
 377     /// Any I/O error from the standard library that's not part of this list.
 378     ///
 379     /// Errors that are `Uncategorized` now may move to a different or a new
 380     /// [`ErrorKind`] variant in the future. It is not recommended to match
 381     /// an error against `Uncategorized`; use a wildcard match (`_`) instead.
 382     #[unstable(feature = "io_error_uncategorized", issue = "none")]
 383     #[doc(hidden)]
 384     Uncategorized,
 385 }
 386
 387 impl ErrorKind {
 388     pub(crate) fn as_str(&self) -> &'static str {
 389         use ErrorKind::*;
 390         // tidy-alphabetical-start
 391         match *self {
 392             AddrInUse => "address in use",
 393             AddrNotAvailable => "address not available",
 394             AlreadyExists => "entity already exists",
 395             ArgumentListTooLong => "argument list too long",
 396             BrokenPipe => "broken pipe",
 397             ConnectionAborted => "connection aborted",
 398             ConnectionRefused => "connection refused",
 399             ConnectionReset => "connection reset",
 400             CrossesDevices => "cross-device link or rename",
 401             Deadlock => "deadlock",
 402             DirectoryNotEmpty => "directory not empty",
 403             ExecutableFileBusy => "executable file busy",
 404             FileTooLarge => "file too large",
 405             FilesystemLoop => "filesystem loop or indirection limit (e.g. symlink loop)",
 406             FilesystemQuotaExceeded => "filesystem quota exceeded",
 407             HostUnreachable => "host unreachable",
 408             Interrupted => "operation interrupted",
 409             InvalidData => "invalid data",
 410             InvalidFilename => "invalid filename",
 411             InvalidInput => "invalid input parameter",
 412             IsADirectory => "is a directory",
 413             NetworkDown => "network down",
 414             NetworkUnreachable => "network unreachable",
 415             NotADirectory => "not a directory",
 416             NotConnected => "not connected",
 417             NotFound => "entity not found",
 418             NotSeekable => "seek on unseekable file",
 419             Other => "other error",
 420             OutOfMemory => "out of memory",
 421             PermissionDenied => "permission denied",
 422             ReadOnlyFilesystem => "read-only filesystem or storage medium",
 423             ResourceBusy => "resource busy",
 424             StaleNetworkFileHandle => "stale network file handle",
 425             StorageFull => "no storage space",
 426             TimedOut => "timed out",
 427             TooManyLinks => "too many links",
 428             Uncategorized => "uncategorized error",
 429             UnexpectedEof => "unexpected end of file",
 430             Unsupported => "unsupported",
 431             WouldBlock => "operation would block",
 432             WriteZero => "write zero",
 433         }
 434         // tidy-alphabetical-end
 435     }
 436 }
 437
 438 #[stable(feature = "io_errorkind_display", since = "1.60.0")]
 439 impl fmt::Display for ErrorKind {
 440     /// Shows a human-readable description of the `ErrorKind`.
 441     ///
 442     /// This is similar to `impl Display for Error`, but doesn't require first converting to Error.
 443     ///
 444     /// # Examples
 445     /// ```
 446     /// use std::io::ErrorKind;
 447     /// assert_eq!("entity not found", ErrorKind::NotFound.to_string());
 448     /// ```
 449     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 450         fmt.write_str(self.as_str())
 451     }
 452 }
 453
 454 /// Intended for use for errors not exposed to the user, where allocating onto
 455 /// the heap (for normal construction via Error::new) is too costly.
 456 #[stable(feature = "io_error_from_errorkind", since = "1.14.0")]
 457 impl From<ErrorKind> for Error {
 458     /// Converts an [`ErrorKind`] into an [`Error`].
 459     ///
 460     /// This conversion creates a new error with a simple representation of error kind.
 461     ///
 462     /// # Examples
 463     ///
 464     /// ```
 465     /// use std::io::{Error, ErrorKind};
 466     ///
 467     /// let not_found = ErrorKind::NotFound;
 468     /// let error = Error::from(not_found);
 469     /// assert_eq!("entity not found", format!("{error}"));
 470     /// ```
 471     #[inline]
 472     fn from(kind: ErrorKind) -> Error {
 473         Error { repr: Repr::new_simple(kind) }
 474     }
 475 }
 476
 477 impl Error {
 478     /// Creates a new I/O error from a known kind of error as well as an
 479     /// arbitrary error payload.
 480     ///
 481     /// This function is used to generically create I/O errors which do not
 482     /// originate from the OS itself. The `error` argument is an arbitrary
 483     /// payload which will be contained in this [`Error`].
 484     ///
 485     /// Note that this function allocates memory on the heap.
 486     /// If no extra payload is required, use the `From` conversion from
 487     /// `ErrorKind`.
 488     ///
 489     /// # Examples
 490     ///
 491     /// ```
 492     /// use std::io::{Error, ErrorKind};
 493     ///
 494     /// // errors can be created from strings
 495     /// let custom_error = Error::new(ErrorKind::Other, "oh no!");
 496     ///
 497     /// // errors can also be created from other errors
 498     /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
 499     ///
 500     /// // creating an error without payload (and without memory allocation)
 501     /// let eof_error = Error::from(ErrorKind::UnexpectedEof);
 502     /// ```
 503     #[stable(feature = "rust1", since = "1.0.0")]
 504     pub fn new<E>(kind: ErrorKind, error: E) -> Error
 505     where
 506         E: Into<Box<dyn error::Error + Send + Sync>>,
 507     {
 508         Self::_new(kind, error.into())
 509     }
 510
 511     /// Creates a new I/O error from an arbitrary error payload.
 512     ///
 513     /// This function is used to generically create I/O errors which do not
 514     /// originate from the OS itself. It is a shortcut for [`Error::new`]
 515     /// with [`ErrorKind::Other`].
 516     ///
 517     /// # Examples
 518     ///
 519     /// ```
 520     /// #![feature(io_error_other)]
 521     ///
 522     /// use std::io::Error;
 523     ///
 524     /// // errors can be created from strings
 525     /// let custom_error = Error::other("oh no!");
 526     ///
 527     /// // errors can also be created from other errors
 528     /// let custom_error2 = Error::other(custom_error);
 529     /// ```
 530     #[unstable(feature = "io_error_other", issue = "91946")]
 531     pub fn other<E>(error: E) -> Error
 532     where
 533         E: Into<Box<dyn error::Error + Send + Sync>>,
 534     {
 535         Self::_new(ErrorKind::Other, error.into())
 536     }
 537
 538     fn _new(kind: ErrorKind, error: Box<dyn error::Error + Send + Sync>) -> Error {
 539         Error { repr: Repr::new_custom(Box::new(Custom { kind, error })) }
 540     }
 541
 542     /// Creates a new I/O error from a known kind of error as well as a constant
 543     /// message.
 544     ///
 545     /// This function does not allocate.
 546     ///
 547     /// You should not use this directly, and instead use the `const_io_error!`
 548     /// macro: `io::const_io_error!(ErrorKind::Something, "some_message")`.
 549     ///
 550     /// This function should maybe change to `from_static_message<const MSG: &'static
 551     /// str>(kind: ErrorKind)` in the future, when const generics allow that.
 552     #[inline]
 553     pub(crate) const fn from_static_message(msg: &'static SimpleMessage) -> Error {
 554         Self { repr: Repr::new_simple_message(msg) }
 555     }
 556
 557     /// Returns an error representing the last OS error which occurred.
 558     ///
 559     /// This function reads the value of `errno` for the target platform (e.g.
 560     /// `GetLastError` on Windows) and will return a corresponding instance of
 561     /// [`Error`] for the error code.
 562     ///
 563     /// This should be called immediately after a call to a platform function,
 564     /// otherwise the state of the error value is indeterminate. In particular,
 565     /// other standard library functions may call platform functions that may
 566     /// (or may not) reset the error value even if they succeed.
 567     ///
 568     /// # Examples
 569     ///
 570     /// ```
 571     /// use std::io::Error;
 572     ///
 573     /// let os_error = Error::last_os_error();
 574     /// println!("last OS error: {os_error:?}");
 575     /// ```
 576     #[stable(feature = "rust1", since = "1.0.0")]
 577     #[doc(alias = "GetLastError")]
 578     #[doc(alias = "errno")]
 579     #[must_use]
 580     #[inline]
 581     pub fn last_os_error() -> Error {
 582         Error::from_raw_os_error(sys::os::errno() as i32)
 583     }
 584
 585     /// Creates a new instance of an [`Error`] from a particular OS error code.
 586     ///
 587     /// # Examples
 588     ///
 589     /// On Linux:
 590     ///
 591     /// ```
 592     /// # if cfg!(target_os = "linux") {
 593     /// use std::io;
 594     ///
 595     /// let error = io::Error::from_raw_os_error(22);
 596     /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
 597     /// # }
 598     /// ```
 599     ///
 600     /// On Windows:
 601     ///
 602     /// ```
 603     /// # if cfg!(windows) {
 604     /// use std::io;
 605     ///
 606     /// let error = io::Error::from_raw_os_error(10022);
 607     /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
 608     /// # }
 609     /// ```
 610     #[stable(feature = "rust1", since = "1.0.0")]
 611     #[must_use]
 612     #[inline]
 613     pub fn from_raw_os_error(code: i32) -> Error {
 614         Error { repr: Repr::new_os(code) }
 615     }
 616
 617     /// Returns the OS error that this error represents (if any).
 618     ///
 619     /// If this [`Error`] was constructed via [`last_os_error`] or
 620     /// [`from_raw_os_error`], then this function will return [`Some`], otherwise
 621     /// it will return [`None`].
 622     ///
 623     /// [`last_os_error`]: Error::last_os_error
 624     /// [`from_raw_os_error`]: Error::from_raw_os_error
 625     ///
 626     /// # Examples
 627     ///
 628     /// ```
 629     /// use std::io::{Error, ErrorKind};
 630     ///
 631     /// fn print_os_error(err: &Error) {
 632     ///     if let Some(raw_os_err) = err.raw_os_error() {
 633     ///         println!("raw OS error: {raw_os_err:?}");
 634     ///     } else {
 635     ///         println!("Not an OS error");
 636     ///     }
 637     /// }
 638     ///
 639     /// fn main() {
 640     ///     // Will print "raw OS error: ...".
 641     ///     print_os_error(&Error::last_os_error());
 642     ///     // Will print "Not an OS error".
 643     ///     print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
 644     /// }
 645     /// ```
 646     #[stable(feature = "rust1", since = "1.0.0")]
 647     #[must_use]
 648     #[inline]
 649     pub fn raw_os_error(&self) -> Option<i32> {
 650         match self.repr.data() {
 651             ErrorData::Os(i) => Some(i),
 652             ErrorData::Custom(..) => None,
 653             ErrorData::Simple(..) => None,
 654             ErrorData::SimpleMessage(..) => None,
 655         }
 656     }
 657
 658     /// Returns a reference to the inner error wrapped by this error (if any).
 659     ///
 660     /// If this [`Error`] was constructed via [`new`] then this function will
 661     /// return [`Some`], otherwise it will return [`None`].
 662     ///
 663     /// [`new`]: Error::new
 664     ///
 665     /// # Examples
 666     ///
 667     /// ```
 668     /// use std::io::{Error, ErrorKind};
 669     ///
 670     /// fn print_error(err: &Error) {
 671     ///     if let Some(inner_err) = err.get_ref() {
 672     ///         println!("Inner error: {inner_err:?}");
 673     ///     } else {
 674     ///         println!("No inner error");
 675     ///     }
 676     /// }
 677     ///
 678     /// fn main() {
 679     ///     // Will print "No inner error".
 680     ///     print_error(&Error::last_os_error());
 681     ///     // Will print "Inner error: ...".
 682     ///     print_error(&Error::new(ErrorKind::Other, "oh no!"));
 683     /// }
 684     /// ```
 685     #[stable(feature = "io_error_inner", since = "1.3.0")]
 686     #[must_use]
 687     #[inline]
 688     pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> {
 689         match self.repr.data() {
 690             ErrorData::Os(..) => None,
 691             ErrorData::Simple(..) => None,
 692             ErrorData::SimpleMessage(..) => None,
 693             ErrorData::Custom(c) => Some(&*c.error),
 694         }
 695     }
 696
 697     /// Returns a mutable reference to the inner error wrapped by this error
 698     /// (if any).
 699     ///
 700     /// If this [`Error`] was constructed via [`new`] then this function will
 701     /// return [`Some`], otherwise it will return [`None`].
 702     ///
 703     /// [`new`]: Error::new
 704     ///
 705     /// # Examples
 706     ///
 707     /// ```
 708     /// use std::io::{Error, ErrorKind};
 709     /// use std::{error, fmt};
 710     /// use std::fmt::Display;
 711     ///
 712     /// #[derive(Debug)]
 713     /// struct MyError {
 714     ///     v: String,
 715     /// }
 716     ///
 717     /// impl MyError {
 718     ///     fn new() -> MyError {
 719     ///         MyError {
 720     ///             v: "oh no!".to_string()
 721     ///         }
 722     ///     }
 723     ///
 724     ///     fn change_message(&mut self, new_message: &str) {
 725     ///         self.v = new_message.to_string();
 726     ///     }
 727     /// }
 728     ///
 729     /// impl error::Error for MyError {}
 730     ///
 731     /// impl Display for MyError {
 732     ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 733     ///         write!(f, "MyError: {}", &self.v)
 734     ///     }
 735     /// }
 736     ///
 737     /// fn change_error(mut err: Error) -> Error {
 738     ///     if let Some(inner_err) = err.get_mut() {
 739     ///         inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
 740     ///     }
 741     ///     err
 742     /// }
 743     ///
 744     /// fn print_error(err: &Error) {
 745     ///     if let Some(inner_err) = err.get_ref() {
 746     ///         println!("Inner error: {inner_err}");
 747     ///     } else {
 748     ///         println!("No inner error");
 749     ///     }
 750     /// }
 751     ///
 752     /// fn main() {
 753     ///     // Will print "No inner error".
 754     ///     print_error(&change_error(Error::last_os_error()));
 755     ///     // Will print "Inner error: ...".
 756     ///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
 757     /// }
 758     /// ```
 759     #[stable(feature = "io_error_inner", since = "1.3.0")]
 760     #[must_use]
 761     #[inline]
 762     pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> {
 763         match self.repr.data_mut() {
 764             ErrorData::Os(..) => None,
 765             ErrorData::Simple(..) => None,
 766             ErrorData::SimpleMessage(..) => None,
 767             ErrorData::Custom(c) => Some(&mut *c.error),
 768         }
 769     }
 770
 771     /// Consumes the `Error`, returning its inner error (if any).
 772     ///
 773     /// If this [`Error`] was constructed via [`new`] then this function will
 774     /// return [`Some`], otherwise it will return [`None`].
 775     ///
 776     /// [`new`]: Error::new
 777     ///
 778     /// # Examples
 779     ///
 780     /// ```
 781     /// use std::io::{Error, ErrorKind};
 782     ///
 783     /// fn print_error(err: Error) {
 784     ///     if let Some(inner_err) = err.into_inner() {
 785     ///         println!("Inner error: {inner_err}");
 786     ///     } else {
 787     ///         println!("No inner error");
 788     ///     }
 789     /// }
 790     ///
 791     /// fn main() {
 792     ///     // Will print "No inner error".
 793     ///     print_error(Error::last_os_error());
 794     ///     // Will print "Inner error: ...".
 795     ///     print_error(Error::new(ErrorKind::Other, "oh no!"));
 796     /// }
 797     /// ```
 798     #[stable(feature = "io_error_inner", since = "1.3.0")]
 799     #[must_use = "`self` will be dropped if the result is not used"]
 800     #[inline]
 801     pub fn into_inner(self) -> Option<Box<dyn error::Error + Send + Sync>> {
 802         match self.repr.into_data() {
 803             ErrorData::Os(..) => None,
 804             ErrorData::Simple(..) => None,
 805             ErrorData::SimpleMessage(..) => None,
 806             ErrorData::Custom(c) => Some(c.error),
 807         }
 808     }
 809
 810     /// Attempt to downgrade the inner error to `E` if any.
 811     ///
 812     /// If this [`Error`] was constructed via [`new`] then this function will
 813     /// attempt to perform downgrade on it, otherwise it will return [`Err`].
 814     ///
 815     /// If downgrade succeeds, it will return [`Ok`], otherwise it will also
 816     /// return [`Err`].
 817     ///
 818     /// [`new`]: Error::new
 819     ///
 820     /// # Examples
 821     ///
 822     /// ```
 823     /// #![feature(io_error_downcast)]
 824     ///
 825     /// use std::fmt;
 826     /// use std::io;
 827     /// use std::error::Error;
 828     ///
 829     /// #[derive(Debug)]
 830     /// enum E {
 831     ///     Io(io::Error),
 832     ///     SomeOtherVariant,
 833     /// }
 834     ///
 835     /// impl fmt::Display for E {
 836     ///    // ...
 837     /// #    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 838     /// #        todo!()
 839     /// #    }
 840     /// }
 841     /// impl Error for E {}
 842     ///
 843     /// impl From<io::Error> for E {
 844     ///     fn from(err: io::Error) -> E {
 845     ///         err.downcast::<E>()
 846     ///             .map(|b| *b)
 847     ///             .unwrap_or_else(E::Io)
 848     ///     }
 849     /// }
 850     /// ```
 851     #[unstable(feature = "io_error_downcast", issue = "99262")]
 852     pub fn downcast<E>(self) -> result::Result<Box<E>, Self>
 853     where
 854         E: error::Error + Send + Sync + 'static,
 855     {
 856         match self.repr.into_data() {
 857             ErrorData::Custom(b) if b.error.is::<E>() => {
 858                 let res = (*b).error.downcast::<E>();
 859
 860                 // downcast is a really trivial and is marked as inline, so
 861                 // it's likely be inlined here.
 862                 //
 863                 // And the compiler should be able to eliminate the branch
 864                 // that produces `Err` here since b.error.is::<E>()
 865                 // returns true.
 866                 Ok(res.unwrap())
 867             }
 868             repr_data => Err(Self { repr: Repr::new(repr_data) }),
 869         }
 870     }
 871
 872     /// Returns the corresponding [`ErrorKind`] for this error.
 873     ///
 874     /// # Examples
 875     ///
 876     /// ```
 877     /// use std::io::{Error, ErrorKind};
 878     ///
 879     /// fn print_error(err: Error) {
 880     ///     println!("{:?}", err.kind());
 881     /// }
 882     ///
 883     /// fn main() {
 884     ///     // Will print "Uncategorized".
 885     ///     print_error(Error::last_os_error());
 886     ///     // Will print "AddrInUse".
 887     ///     print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
 888     /// }
 889     /// ```
 890     #[stable(feature = "rust1", since = "1.0.0")]
 891     #[must_use]
 892     #[inline]
 893     pub fn kind(&self) -> ErrorKind {
 894         match self.repr.data() {
 895             ErrorData::Os(code) => sys::decode_error_kind(code),
 896             ErrorData::Custom(c) => c.kind,
 897             ErrorData::Simple(kind) => kind,
 898             ErrorData::SimpleMessage(m) => m.kind,
 899         }
 900     }
 901 }
 902
 903 impl fmt::Debug for Repr {
 904     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 905         match self.data() {
 906             ErrorData::Os(code) => fmt
 907                 .debug_struct("Os")
 908                 .field("code", &code)
 909                 .field("kind", &sys::decode_error_kind(code))
 910                 .field("message", &sys::os::error_string(code))
 911                 .finish(),
 912             ErrorData::Custom(c) => fmt::Debug::fmt(&c, fmt),
 913             ErrorData::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
 914             ErrorData::SimpleMessage(msg) => fmt
 915                 .debug_struct("Error")
 916                 .field("kind", &msg.kind)
 917                 .field("message", &msg.message)
 918                 .finish(),
 919         }
 920     }
 921 }
 922
 923 #[stable(feature = "rust1", since = "1.0.0")]
 924 impl fmt::Display for Error {
 925     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 926         match self.repr.data() {
 927             ErrorData::Os(code) => {
 928                 let detail = sys::os::error_string(code);
 929                 write!(fmt, "{detail} (os error {code})")
 930             }
 931             ErrorData::Custom(ref c) => c.error.fmt(fmt),
 932             ErrorData::Simple(kind) => write!(fmt, "{}", kind.as_str()),
 933             ErrorData::SimpleMessage(msg) => msg.message.fmt(fmt),
 934         }
 935     }
 936 }
 937
 938 #[stable(feature = "rust1", since = "1.0.0")]
 939 impl error::Error for Error {
 940     #[allow(deprecated, deprecated_in_future)]
 941     fn description(&self) -> &str {
 942         match self.repr.data() {
 943             ErrorData::Os(..) | ErrorData::Simple(..) => self.kind().as_str(),
 944             ErrorData::SimpleMessage(msg) => msg.message,
 945             ErrorData::Custom(c) => c.error.description(),
 946         }
 947     }
 948
 949     #[allow(deprecated)]
 950     fn cause(&self) -> Option<&dyn error::Error> {
 951         match self.repr.data() {
 952             ErrorData::Os(..) => None,
 953             ErrorData::Simple(..) => None,
 954             ErrorData::SimpleMessage(..) => None,
 955             ErrorData::Custom(c) => c.error.cause(),
 956         }
 957     }
 958
 959     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
 960         match self.repr.data() {
 961             ErrorData::Os(..) => None,
 962             ErrorData::Simple(..) => None,
 963             ErrorData::SimpleMessage(..) => None,
 964             ErrorData::Custom(c) => c.error.source(),
 965         }
 966     }
 967 }
 968
 969 fn _assert_error_is_sync_send() {
 970     fn _is_sync_send<T: Sync + Send>() {}
 971     _is_sync_send::<Error>();
 972 }