valentineus/fparkan
0
Fork 0
Code Issues Releases Activity

Initial vendor packages

Browse Source 
Signed-off-by: Valentin Popov <valentin@popov.link>
This commit is contained in:
Valentin Popov
2024-01-08 01:21:28 +04:00
parent 5ecd8cf2cb
commit 1b6a04ca55
7309 changed files with 2160054 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
vendor/hermit-abi/.cargo-checksum.json vendored Normal file
View File

@ -0,0 +1 @@
{"files":{"Cargo.toml":"2fdd312de10adc759afb2008d22aa716f275f7ac82b517cafd2adfcf62fb4f14","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"d18b009fb1ac087d121ce82ea4a0f557d63b8641f4be4316ad105b00bf85867d","src/errno.rs":"1c0680ead2ddf26b12d34bd7fa3e1dab386df761d6ac1901889ece26682dc465","src/lib.rs":"ce3e2dc736b3d369a80de2645ed5bb10779c236b5ad12e17d7e257d73780aada","src/tcplistener.rs":"1fb1c0c232d4f24afb6cff63a7541d00029b7159da8d25b2eb257dff078940a0","src/tcpstream.rs":"fce8a598c6331b82e40982eda079d758be324b8941bf76f1031cea8d01632823"},"package":"d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"}

47
vendor/hermit-abi/Cargo.toml vendored Normal file
View File

@ -0,0 +1,47 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
edition = "2021"
name = "hermit-abi"
version = "0.3.3"
authors = ["Stefan Lankes"]
description = "Hermit system calls definitions."
readme = "README.md"
keywords = [
"unikernel",
"libos",
]
categories = ["os"]
license = "MIT OR Apache-2.0"
repository = "https://github.com/hermitcore/hermit-rs"
[dependencies.alloc]
version = "1.0.0"
optional = true
package = "rustc-std-workspace-alloc"
[dependencies.compiler_builtins]
version = "0.1"
optional = true
[dependencies.core]
version = "1.0.0"
optional = true
package = "rustc-std-workspace-core"
[features]
default = []
rustc-dep-of-std = [
"core",
"alloc",
"compiler_builtins/rustc-dep-of-std",
]

201
vendor/hermit-abi/LICENSE-APACHE vendored Normal file
View File

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

23
vendor/hermit-abi/LICENSE-MIT vendored Normal file
View File

@ -0,0 +1,23 @@
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

22
vendor/hermit-abi/README.md vendored Normal file
View File

@ -0,0 +1,22 @@
# hermit-abi
[![Crates.io](https://img.shields.io/crates/v/hermit-abi.svg)](https://crates.io/crates/hermit-abi)
[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://hermitcore.github.io/hermit-rs/hermit_abi/)
[![License](https://img.shields.io/crates/l/hermit-abi.svg)](https://img.shields.io/crates/l/hermit-abi.svg)
This is small interface to call functions from the [Hermit kernel](https://github.com/hermitcore/kernel).
Please read the README of the [Hermit kernel](https://github.com/hermitcore/kernel) for more information.
## License
Licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.
## Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

397
vendor/hermit-abi/src/errno.rs vendored Normal file
View File

@ -0,0 +1,397 @@
/// Operation not permitted
pub const EPERM: i32 = 1;
/// No such file or directory
pub const ENOENT: i32 = 2;
/// No such process
pub const ESRCH: i32 = 3;
/// Interrupted system call
pub const EINTR: i32 = 4;
/// I/O error
pub const EIO: i32 = 5;
/// No such device or address
pub const ENXIO: i32 = 6;
/// Argument list too long
pub const E2BIG: i32 = 7;
/// Exec format error
pub const ENOEXEC: i32 = 8;
/// Bad file number
pub const EBADF: i32 = 9;
/// No child processes
pub const ECHILD: i32 = 10;
/// Try again
pub const EAGAIN: i32 = 11;
/// Out of memory
pub const ENOMEM: i32 = 12;
/// Permission denied
pub const EACCES: i32 = 13;
/// Bad address
pub const EFAULT: i32 = 14;
/// Block device required
pub const ENOTBLK: i32 = 15;
/// Device or resource busy
pub const EBUSY: i32 = 16;
/// File exists
pub const EEXIST: i32 = 17;
/// Cross-device link
pub const EXDEV: i32 = 18;
/// No such device
pub const ENODEV: i32 = 19;
/// Not a directory
pub const ENOTDIR: i32 = 20;
/// Is a directory
pub const EISDIR: i32 = 21;
/// Invalid argument
pub const EINVAL: i32 = 22;
/// File table overflow
pub const ENFILE: i32 = 23;
/// Too many open files
pub const EMFILE: i32 = 24;
/// Not a typewriter
pub const ENOTTY: i32 = 25;
/// Text file busy
pub const ETXTBSY: i32 = 26;
/// File too large
pub const EFBIG: i32 = 27;
/// No space left on device
pub const ENOSPC: i32 = 28;
/// Illegal seek
pub const ESPIPE: i32 = 29;
/// Read-only file system
pub const EROFS: i32 = 30;
/// Too many links
pub const EMLINK: i32 = 31;
/// Broken pipe
pub const EPIPE: i32 = 32;
/// Math argument out of domain of func
pub const EDOM: i32 = 33;
/// Math result not representable
pub const ERANGE: i32 = 34;
/// Resource deadlock would occur
pub const EDEADLK: i32 = 35;
/// File name too long
pub const ENAMETOOLONG: i32 = 36;
/// No record locks available
pub const ENOLCK: i32 = 37;
/// Function not implemented
pub const ENOSYS: i32 = 38;
/// Directory not empty
pub const ENOTEMPTY: i32 = 39;
/// Too many symbolic links encountered
pub const ELOOP: i32 = 40;
/// Operation would block
pub const EWOULDBLOCK: i32 = EAGAIN;
/// No message of desired type
pub const ENOMSG: i32 = 42;
/// Identifier removed
pub const EIDRM: i32 = 43;
/// Channel number out of range
pub const ECHRNG: i32 = 44;
/// Level 2 not synchronized
pub const EL2NSYNC: i32 = 45;
/// Level 3 halted
pub const EL3HLT: i32 = 46;
/// Level 3 reset
pub const EL3RST: i32 = 47;
/// Link number out of range
pub const ELNRNG: i32 = 48;
/// Protocol driver not attached
pub const EUNATCH: i32 = 49;
/// No CSI structure available
pub const ENOCSI: i32 = 50;
/// Level 2 halted
pub const EL2HLT: i32 = 51;
/// Invalid exchange
pub const EBADE: i32 = 52;
/// Invalid request descriptor
pub const EBADR: i32 = 53;
/// Exchange full
pub const EXFULL: i32 = 54;
/// No anode
pub const ENOANO: i32 = 55;
/// Invalid request code
pub const EBADRQC: i32 = 56;
/// Invalid slot
pub const EBADSLT: i32 = 57;
pub const EDEADLOCK: i32 = EDEADLK;
/// Bad font file format
pub const EBFONT: i32 = 59;
/// Device not a stream
pub const ENOSTR: i32 = 60;
/// No data available
pub const ENODATA: i32 = 61;
/// Timer expired
pub const ETIME: i32 = 62;
/// Out of streams resources
pub const ENOSR: i32 = 63;
/// Machine is not on the network
pub const ENONET: i32 = 64;
/// Package not installed
pub const ENOPKG: i32 = 65;
/// Object is remote
pub const EREMOTE: i32 = 66;
/// Link has been severed
pub const ENOLINK: i32 = 67;
/// Advertise error
pub const EADV: i32 = 68;
/// Srmount error
pub const ESRMNT: i32 = 69;
/// Communication error on send
pub const ECOMM: i32 = 70;
/// Protocol error
pub const EPROTO: i32 = 71;
/// Multihop attempted
pub const EMULTIHOP: i32 = 72;
/// RFS specific error
pub const EDOTDOT: i32 = 73;
/// Not a data message
pub const EBADMSG: i32 = 74;
/// Value too large for defined data type
pub const EOVERFLOW: i32 = 75;
/// Name not unique on network
pub const ENOTUNIQ: i32 = 76;
/// File descriptor in bad state
pub const EBADFD: i32 = 77;
/// Remote address changed
pub const EREMCHG: i32 = 78;
/// Can not access a needed shared library
pub const ELIBACC: i32 = 79;
/// Accessing a corrupted shared library
pub const ELIBBAD: i32 = 80;
/// .lib section in a.out corrupted
pub const ELIBSCN: i32 = 81;
/// Attempting to link in too many shared libraries
pub const ELIBMAX: i32 = 82;
/// Cannot exec a shared library directly
pub const ELIBEXEC: i32 = 83;
/// Illegal byte sequence
pub const EILSEQ: i32 = 84;
/// Interrupted system call should be restarted
pub const ERESTART: i32 = 85;
/// Streams pipe error
pub const ESTRPIPE: i32 = 86;
/// Too many users
pub const EUSERS: i32 = 87;
/// Socket operation on non-socket
pub const ENOTSOCK: i32 = 88;
/// Destination address required
pub const EDESTADDRREQ: i32 = 89;
/// Message too long
pub const EMSGSIZE: i32 = 90;
/// Protocol wrong type for socket
pub const EPROTOTYPE: i32 = 91;
/// Protocol not available
pub const ENOPROTOOPT: i32 = 92;
/// Protocol not supported
pub const EPROTONOSUPPORT: i32 = 93;
/// Socket type not supported
pub const ESOCKTNOSUPPORT: i32 = 94;
/// Operation not supported on transport endpoint
pub const EOPNOTSUPP: i32 = 95;
/// Protocol family not supported
pub const EPFNOSUPPORT: i32 = 96;
/// Address family not supported by protocol
pub const EAFNOSUPPORT: i32 = 97;
/// Address already in use
pub const EADDRINUSE: i32 = 98;
/// Cannot assign requested address
pub const EADDRNOTAVAIL: i32 = 99;
/// Network is down
pub const ENETDOWN: i32 = 100;
/// Network is unreachable
pub const ENETUNREACH: i32 = 101;
/// Network dropped connection because of reset
pub const ENETRESET: i32 = 102;
/// Software caused connection abort
pub const ECONNABORTED: i32 = 103;
/// Connection reset by peer
pub const ECONNRESET: i32 = 104;
/// No buffer space available
pub const ENOBUFS: i32 = 105;
/// Transport endpoint is already connected
pub const EISCONN: i32 = 106;
/// Transport endpoint is not connected
pub const ENOTCONN: i32 = 107;
/// Cannot send after transport endpoint shutdown
pub const ESHUTDOWN: i32 = 108;
/// Too many references: cannot splice
pub const ETOOMANYREFS: i32 = 109;
/// Connection timed out
pub const ETIMEDOUT: i32 = 110;
/// Connection refused
pub const ECONNREFUSED: i32 = 111;
/// Host is down
pub const EHOSTDOWN: i32 = 112;
/// No route to host
pub const EHOSTUNREACH: i32 = 113;
/// Operation already in progress
pub const EALREADY: i32 = 114;
/// Operation now in progress
pub const EINPROGRESS: i32 = 115;
/// Stale file handle
pub const ESTALE: i32 = 116;
/// Structure needs cleaning
pub const EUCLEAN: i32 = 117;
/// Not a XENIX named type file
pub const ENOTNAM: i32 = 118;
/// No XENIX semaphores available
pub const ENAVAIL: i32 = 119;
/// Is a named type file
pub const EISNAM: i32 = 120;
/// Remote I/O error
pub const EREMOTEIO: i32 = 121;
/// Quota exceeded
pub const EDQUOT: i32 = 122;
/// No medium found
pub const ENOMEDIUM: i32 = 123;
/// Wrong medium type
pub const EMEDIUMTYPE: i32 = 124;
/// Operation Canceled
pub const ECANCELED: i32 = 125;
/// Required key not available
pub const ENOKEY: i32 = 126;
/// Key has expired
pub const EKEYEXPIRED: i32 = 127;
/// Key has been revoked
pub const EKEYREVOKED: i32 = 128;
/// Key was rejected by service
pub const EKEYREJECTED: i32 = 129;
/// Robust mutexes: Owner died
pub const EOWNERDEAD: i32 = 130;
/// Robust mutexes: State not recoverable
pub const ENOTRECOVERABLE: i32 = 131;
/// Robust mutexes: Operation not possible due to RF-kill
pub const ERFKILL: i32 = 132;
/// Robust mutexes: Memory page has hardware error
pub const EHWPOISON: i32 = 133;

697
vendor/hermit-abi/src/lib.rs vendored Normal file
View File

@ -0,0 +1,697 @@
//! `hermit-abi` is small interface to call functions from the
//! [Hermit unikernel](https://github.com/hermitcore/kernel).
#![no_std]
#![allow(nonstandard_style)]
#![allow(clippy::missing_safety_doc)]
#![allow(clippy::result_unit_err)]
pub mod errno;
pub mod tcplistener;
pub mod tcpstream;
use core::ffi::{c_int, c_void};
/// A thread handle type
pub type Tid = u32;
/// Maximum number of priorities
pub const NO_PRIORITIES: usize = 31;
/// Priority of a thread
#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
pub struct Priority(u8);
impl Priority {
pub const fn into(self) -> u8 {
self.0
}
pub const fn from(x: u8) -> Self {
Priority(x)
}
}
pub const HIGH_PRIO: Priority = Priority::from(3);
pub const NORMAL_PRIO: Priority = Priority::from(2);
pub const LOW_PRIO: Priority = Priority::from(1);
/// A handle, identifying a socket
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
pub struct Handle(usize);
pub const NSEC_PER_SEC: u64 = 1_000_000_000;
pub const FUTEX_RELATIVE_TIMEOUT: u32 = 1;
pub const CLOCK_REALTIME: u64 = 1;
pub const CLOCK_MONOTONIC: u64 = 4;
pub const STDIN_FILENO: c_int = 0;
pub const STDOUT_FILENO: c_int = 1;
pub const STDERR_FILENO: c_int = 2;
pub const O_RDONLY: i32 = 0o0;
pub const O_WRONLY: i32 = 0o1;
pub const O_RDWR: i32 = 0o2;
pub const O_CREAT: i32 = 0o100;
pub const O_EXCL: i32 = 0o200;
pub const O_TRUNC: i32 = 0o1000;
pub const O_APPEND: i32 = 0o2000;
/// returns true if file descriptor `fd` is a tty
pub fn isatty(_fd: c_int) -> bool {
false
}
/// `timespec` is used by `clock_gettime` to retrieve the
/// current time
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct timespec {
/// seconds
pub tv_sec: i64,
/// nanoseconds
pub tv_nsec: i64,
}
/// Internet protocol version.
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum Version {
Unspecified,
Ipv4,
Ipv6,
}
/// A four-octet IPv4 address.
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
pub struct Ipv4Address(pub [u8; 4]);
/// A sixteen-octet IPv6 address.
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
pub struct Ipv6Address(pub [u8; 16]);
/// An internetworking address.
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum IpAddress {
/// An unspecified address.
/// May be used as a placeholder for storage where the address is not assigned yet.
Unspecified,
/// An IPv4 address.
Ipv4(Ipv4Address),
/// An IPv6 address.
Ipv6(Ipv6Address),
}
/// The largest number `rand` will return
pub const RAND_MAX: u64 = 2_147_483_647;
pub const AF_INET: i32 = 0;
pub const AF_INET6: i32 = 1;
pub const IPPROTO_IP: i32 = 0;
pub const IPPROTO_IPV6: i32 = 41;
pub const IPPROTO_UDP: i32 = 17;
pub const IPPROTO_TCP: i32 = 6;
pub const IPV6_ADD_MEMBERSHIP: i32 = 12;
pub const IPV6_DROP_MEMBERSHIP: i32 = 13;
pub const IPV6_MULTICAST_LOOP: i32 = 19;
pub const IPV6_V6ONLY: i32 = 27;
pub const IP_TTL: i32 = 2;
pub const IP_MULTICAST_TTL: i32 = 5;
pub const IP_MULTICAST_LOOP: i32 = 7;
pub const IP_ADD_MEMBERSHIP: i32 = 3;
pub const IP_DROP_MEMBERSHIP: i32 = 4;
pub const SHUT_RD: i32 = 0;
pub const SHUT_WR: i32 = 1;
pub const SHUT_RDWR: i32 = 2;
pub const SOCK_DGRAM: i32 = 2;
pub const SOCK_STREAM: i32 = 1;
pub const SOL_SOCKET: i32 = 4095;
pub const SO_BROADCAST: i32 = 32;
pub const SO_ERROR: i32 = 4103;
pub const SO_RCVTIMEO: i32 = 4102;
pub const SO_REUSEADDR: i32 = 4;
pub const SO_SNDTIMEO: i32 = 4101;
pub const SO_LINGER: i32 = 128;
pub const TCP_NODELAY: i32 = 1;
pub const MSG_PEEK: i32 = 1;
pub const FIONBIO: i32 = 0x8008667eu32 as i32;
pub const EAI_NONAME: i32 = -2200;
pub const EAI_SERVICE: i32 = -2201;
pub const EAI_FAIL: i32 = -2202;
pub const EAI_MEMORY: i32 = -2203;
pub const EAI_FAMILY: i32 = -2204;
pub const POLLIN: i16 = 0x1;
pub const POLLPRI: i16 = 0x2;
pub const POLLOUT: i16 = 0x4;
pub const POLLERR: i16 = 0x8;
pub const POLLHUP: i16 = 0x10;
pub const POLLNVAL: i16 = 0x20;
pub const POLLRDNORM: i16 = 0x040;
pub const POLLRDBAND: i16 = 0x080;
pub const POLLRDHUP: i16 = 0x2000;
pub type sa_family_t = u8;
pub type socklen_t = u32;
pub type in_addr_t = u32;
pub type in_port_t = u16;
pub type time_t = i64;
pub type suseconds_t = i64;
pub type nfds_t = usize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct in_addr {
pub s_addr: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct in6_addr {
pub s6_addr: [u8; 16],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr {
pub sa_len: u8,
pub sa_family: sa_family_t,
pub sa_data: [u8; 14],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr_in {
pub sin_len: u8,
pub sin_family: sa_family_t,
pub sin_port: u16,
pub sin_addr: in_addr,
pub sin_zero: [u8; 8],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr_in6 {
pub sin6_family: sa_family_t,
pub sin6_port: u16,
pub sin6_addr: in6_addr,
pub sin6_flowinfo: u32,
pub sin6_scope_id: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct addrinfo {
pub ai_flags: i32,
pub ai_family: i32,
pub ai_socktype: i32,
pub ai_protocol: i32,
pub ai_addrlen: socklen_t,
pub ai_addr: *mut sockaddr,
pub ai_canonname: *mut u8,
pub ai_next: *mut addrinfo,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr_storage {
pub s2_len: u8,
pub ss_family: sa_family_t,
pub s2_data1: [i8; 2usize],
pub s2_data2: [u32; 3usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ip_mreq {
pub imr_multiaddr: in_addr,
pub imr_interface: in_addr,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ipv6_mreq {
pub ipv6mr_multiaddr: in6_addr,
pub ipv6mr_interface: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct linger {
pub l_onoff: i32,
pub l_linger: i32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: time_t,
pub tv_usec: suseconds_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pollfd {
pub fd: i32, /* file descriptor */
pub events: i16, /* events to look for */
pub revents: i16, /* events returned */
}
#[repr(C)]
pub struct dirent {
pub d_ino: u64,
pub d_off: u64,
pub d_namelen: u32,
pub d_type: u32,
pub d_name: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub enum DirectoryEntry {
Invalid(i32),
Valid(*const dirent),
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stat {
pub st_dev: u64,
pub st_ino: u64,
pub st_nlink: u64,
pub st_mode: u32,
pub st_uid: u32,
pub st_gid: u32,
pub st_rdev: u64,
pub st_size: i64,
pub st_blksize: i64,
pub st_blocks: i64,
pub st_atime: i64,
pub st_atime_nsec: i64,
pub st_mtime: i64,
pub st_mtime_nsec: i64,
pub st_ctime: i64,
pub st_ctime_nsec: i64,
}
pub const DT_UNKNOWN: u32 = 0;
pub const DT_FIFO: u32 = 1;
pub const DT_CHR: u32 = 2;
pub const DT_DIR: u32 = 4;
pub const DT_BLK: u32 = 6;
pub const DT_REG: u32 = 8;
pub const DT_LNK: u32 = 10;
pub const DT_SOCK: u32 = 12;
pub const DT_WHT: u32 = 14;
pub const S_IFDIR: u32 = 16384;
pub const S_IFREG: u32 = 32768;
pub const S_IFLNK: u32 = 40960;
pub const S_IFMT: u32 = 61440;
// sysmbols, which are part of the library operating system
extern "C" {
/// If the value at address matches the expected value, park the current thread until it is either
/// woken up with [`futex_wake`] (returns 0) or an optional timeout elapses (returns -ETIMEDOUT).
///
/// Setting `timeout` to null means the function will only return if [`futex_wake`] is called.
/// Otherwise, `timeout` is interpreted as an absolute time measured with [`CLOCK_MONOTONIC`].
/// If [`FUTEX_RELATIVE_TIMEOUT`] is set in `flags` the timeout is understood to be relative
/// to the current time.
///
/// Returns -EINVAL if `address` is null, the timeout is negative or `flags` contains unknown values.
#[link_name = "sys_futex_wait"]
pub fn futex_wait(
address: *mut u32,
expected: u32,
timeout: *const timespec,
flags: u32,
) -> i32;
/// Wake `count` threads waiting on the futex at `address`. Returns the number of threads
/// woken up (saturates to `i32::MAX`). If `count` is `i32::MAX`, wake up all matching
/// waiting threads. If `count` is negative or `address` is null, returns -EINVAL.
#[link_name = "sys_futex_wake"]
pub fn futex_wake(address: *mut u32, count: i32) -> i32;
/// sem_init() initializes the unnamed semaphore at the address
/// pointed to by `sem`. The `value` argument specifies the
/// initial value for the semaphore.
#[link_name = "sys_sem_init"]
pub fn sem_init(sem: *mut *const c_void, value: u32) -> i32;
/// sem_destroy() frees the unnamed semaphore at the address
/// pointed to by `sem`.
#[link_name = "sys_sem_destroy"]
pub fn sem_destroy(sem: *const c_void) -> i32;
/// sem_post() increments the semaphore pointed to by `sem`.
/// If the semaphore's value consequently becomes greater
/// than zero, then another thread blocked in a sem_wait call
/// will be woken up and proceed to lock the semaphore.
#[link_name = "sys_sem_post"]
pub fn sem_post(sem: *const c_void) -> i32;
/// try to decrement a semaphore
///
/// sem_trywait() is the same as sem_timedwait(), except that
/// if the decrement cannot be immediately performed, then call
/// returns a negative value instead of blocking.
#[link_name = "sys_sem_trywait"]
pub fn sem_trywait(sem: *const c_void) -> i32;
/// decrement a semaphore
///
/// sem_timedwait() decrements the semaphore pointed to by `sem`.
/// If the semaphore's value is greater than zero, then the
/// the function returns immediately. If the semaphore currently
/// has the value zero, then the call blocks until either
/// it becomes possible to perform the decrement of the time limit
/// to wait for the semaphore is expired. A time limit `ms` of
/// means infinity waiting time.
#[link_name = "sys_timedwait"]
pub fn sem_timedwait(sem: *const c_void, ms: u32) -> i32;
/// Determines the id of the current thread
#[link_name = "sys_getpid"]
pub fn getpid() -> u32;
/// cause normal termination and return `arg`
/// to the host system
#[link_name = "sys_exit"]
pub fn exit(arg: i32) -> !;
/// cause abnormal termination
#[link_name = "sys_abort"]
pub fn abort() -> !;
/// suspend execution for microsecond intervals
///
/// The usleep() function suspends execution of the calling
/// thread for (at least) `usecs` microseconds.
#[link_name = "sys_usleep"]
pub fn usleep(usecs: u64);
/// spawn a new thread
///
/// spawn() starts a new thread. The new thread starts execution
/// by invoking `func(usize)`; `arg` is passed as the argument
/// to `func`. `prio` defines the priority of the new thread,
/// which can be between `LOW_PRIO` and `HIGH_PRIO`.
/// `core_id` defines the core, where the thread is located.
/// A negative value give the operating system the possibility
/// to select the core by its own.
#[link_name = "sys_spawn"]
pub fn spawn(
id: *mut Tid,
func: extern "C" fn(usize),
arg: usize,
prio: u8,
core_id: isize,
) -> i32;
/// spawn a new thread with user-specified stack size
///
/// spawn2() starts a new thread. The new thread starts execution
/// by invoking `func(usize)`; `arg` is passed as the argument
/// to `func`. `prio` defines the priority of the new thread,
/// which can be between `LOW_PRIO` and `HIGH_PRIO`.
/// `core_id` defines the core, where the thread is located.
/// A negative value give the operating system the possibility
/// to select the core by its own.
/// In contrast to spawn(), spawn2() is able to define the
/// stack size.
#[link_name = "sys_spawn2"]
pub fn spawn2(
func: extern "C" fn(usize),
arg: usize,
prio: u8,
stack_size: usize,
core_id: isize,
) -> Tid;
/// join with a terminated thread
///
/// The join() function waits for the thread specified by `id`
/// to terminate.
#[link_name = "sys_join"]
pub fn join(id: Tid) -> i32;
/// yield the processor
///
/// causes the calling thread to relinquish the CPU. The thread
/// is moved to the end of the queue for its static priority.
#[link_name = "sys_yield"]
pub fn yield_now();
/// get current time
///
/// The clock_gettime() functions allow the calling thread
/// to retrieve the value used by a clock which is specified
/// by `clock_id`.
///
/// `CLOCK_REALTIME`: the system's real time clock,
/// expressed as the amount of time since the Epoch.
///
/// `CLOCK_MONOTONIC`: clock that increments monotonically,
/// tracking the time since an arbitrary point
#[link_name = "sys_clock_gettime"]
pub fn clock_gettime(clock_id: u64, tp: *mut timespec) -> i32;
/// open and possibly create a file
///
/// The open() system call opens the file specified by `name`.
/// If the specified file does not exist, it may optionally
/// be created by open().
#[link_name = "sys_open"]
pub fn open(name: *const i8, flags: i32, mode: i32) -> i32;
/// open a directory
///
/// The opendir() system call opens the directory specified by `name`.
#[link_name = "sys_opendir"]
pub fn opendir(name: *const i8) -> i32;
/// delete the file it refers to `name`
#[link_name = "sys_unlink"]
pub fn unlink(name: *const i8) -> i32;
/// remove directory it refers to `name`
#[link_name = "sys_rmdir"]
pub fn rmdir(name: *const i8) -> i32;
/// stat
#[link_name = "sys_stat"]
pub fn stat(name: *const i8, stat: *mut stat) -> i32;
/// lstat
#[link_name = "sys_lstat"]
pub fn lstat(name: *const i8, stat: *mut stat) -> i32;
/// fstat
#[link_name = "sys_fstat"]
pub fn fstat(fd: i32, stat: *mut stat) -> i32;
/// determines the number of activated processors
#[link_name = "sys_get_processor_count"]
pub fn get_processor_count() -> usize;
#[link_name = "sys_malloc"]
pub fn malloc(size: usize, align: usize) -> *mut u8;
#[doc(hidden)]
#[link_name = "sys_realloc"]
pub fn realloc(ptr: *mut u8, size: usize, align: usize, new_size: usize) -> *mut u8;
#[doc(hidden)]
#[link_name = "sys_free"]
pub fn free(ptr: *mut u8, size: usize, align: usize);
#[link_name = "sys_notify"]
pub fn notify(id: usize, count: i32) -> i32;
#[doc(hidden)]
#[link_name = "sys_add_queue"]
pub fn add_queue(id: usize, timeout_ns: i64) -> i32;
#[doc(hidden)]
#[link_name = "sys_wait"]
pub fn wait(id: usize) -> i32;
#[doc(hidden)]
#[link_name = "sys_init_queue"]
pub fn init_queue(id: usize) -> i32;
#[doc(hidden)]
#[link_name = "sys_destroy_queue"]
pub fn destroy_queue(id: usize) -> i32;
/// initialize the network stack
#[link_name = "sys_network_init"]
pub fn network_init() -> i32;
/// Add current task to the queue of blocked tasks. After calling `block_current_task`,
/// call `yield_now` to switch to another task.
#[link_name = "sys_block_current_task"]
pub fn block_current_task();
/// Add current task to the queue of blocked tasks, but wake it when `timeout` milliseconds
/// have elapsed.
///
/// After calling `block_current_task`, call `yield_now` to switch to another task.
#[link_name = "sys_block_current_task_with_timeout"]
pub fn block_current_task_with_timeout(timeout: u64);
/// Wakeup task with the thread id `tid`
#[link_name = "sys_wakeup_taskt"]
pub fn wakeup_task(tid: Tid);
#[link_name = "sys_accept"]
pub fn accept(s: i32, addr: *mut sockaddr, addrlen: *mut socklen_t) -> i32;
/// bind a name to a socket
#[link_name = "sys_bind"]
pub fn bind(s: i32, name: *const sockaddr, namelen: socklen_t) -> i32;
#[link_name = "sys_connect"]
pub fn connect(s: i32, name: *const sockaddr, namelen: socklen_t) -> i32;
/// read from a file descriptor
///
/// read() attempts to read `len` bytes of data from the object
/// referenced by the descriptor `fd` into the buffer pointed
/// to by `buf`.
#[link_name = "sys_read"]
pub fn read(fd: i32, buf: *mut u8, len: usize) -> isize;
/// 'readdir' returns a pointer to a dirent structure
/// representing the next directory entry in the directory stream
/// pointed to by the file descriptor
#[link_name = "sys_readdir"]
pub fn readdir(fd: i32) -> DirectoryEntry;
/// 'mkdir' attempts to create a directory,
/// it returns 0 on success and -1 on error
#[link_name = "sys_mkdir"]
pub fn mkdir(name: *const i8, mode: u32) -> i32;
/// Fill `len` bytes in `buf` with cryptographically secure random data.
///
/// Returns either the number of bytes written to buf (a positive value) or
/// * `-EINVAL` if `flags` contains unknown flags.
/// * `-ENOSYS` if the system does not support random data generation.
#[link_name = "sys_read_entropy"]
pub fn read_entropy(buf: *mut u8, len: usize, flags: u32) -> isize;
/// receive() a message from a socket
#[link_name = "sys_recv"]
pub fn recv(socket: i32, buf: *mut u8, len: usize, flags: i32) -> isize;
/// receive() a message from a socket
#[link_name = "sys_recvfrom"]
pub fn recvfrom(
socket: i32,
buf: *mut u8,
len: usize,
flags: i32,
addr: *mut sockaddr,
addrlen: *mut socklen_t,
) -> isize;
/// write to a file descriptor
///
/// write() attempts to write `len` of data to the object
/// referenced by the descriptor `fd` from the
/// buffer pointed to by `buf`.
#[link_name = "sys_write"]
pub fn write(fd: i32, buf: *const u8, len: usize) -> isize;
/// close a file descriptor
///
/// The close() call deletes a file descriptor `fd` from the object
/// reference table.
#[link_name = "sys_close"]
pub fn close(fd: i32) -> i32;
/// duplicate an existing file descriptor
#[link_name = "sys_dup"]
pub fn dup(fd: i32) -> i32;
#[link_name = "sys_getpeername"]
pub fn getpeername(s: i32, name: *mut sockaddr, namelen: *mut socklen_t) -> i32;
#[link_name = "sys_getsockname"]
pub fn getsockname(s: i32, name: *mut sockaddr, namelen: *mut socklen_t) -> i32;
#[link_name = "sys_getsockopt"]
pub fn getsockopt(
s: i32,
level: i32,
optname: i32,
optval: *mut c_void,
optlen: *mut socklen_t,
) -> i32;
#[link_name = "sys_setsockopt"]
pub fn setsockopt(
s: i32,
level: i32,
optname: i32,
optval: *const c_void,
optlen: socklen_t,
) -> i32;
#[link_name = "sys_ioctl"]
pub fn ioctl(s: i32, cmd: i32, argp: *mut c_void) -> i32;
#[link_name = "sys_pool"]
pub fn poll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32;
/// listen for connections on a socket
///
/// The `backlog` parameter defines the maximum length for the queue of pending
/// connections. Currently, the `backlog` must be one.
#[link_name = "sys_listen"]
pub fn listen(s: i32, backlog: i32) -> i32;
#[link_name = "sys_send"]
pub fn send(s: i32, mem: *const c_void, len: usize, flags: i32) -> isize;
#[link_name = "sys_sendto"]
pub fn sendto(
s: i32,
mem: *const c_void,
len: usize,
flags: i32,
to: *const sockaddr,
tolen: socklen_t,
) -> isize;
/// shut down part of a full-duplex connection
#[link_name = "sys_shutdown_socket"]
pub fn shutdown_socket(s: i32, how: i32) -> i32;
#[link_name = "sys_socket"]
pub fn socket(domain: i32, type_: i32, protocol: i32) -> i32;
#[link_name = "sys_freeaddrinfo"]
pub fn freeaddrinfo(ai: *mut addrinfo);
#[link_name = "sys_getaddrinfo"]
pub fn getaddrinfo(
nodename: *const i8,
servname: *const u8,
hints: *const addrinfo,
res: *mut *mut addrinfo,
) -> i32;
fn sys_get_priority() -> u8;
fn sys_set_priority(tid: Tid, prio: u8);
}
/// Determine the priority of the current thread
#[inline(always)]
pub unsafe fn get_priority() -> Priority {
Priority::from(sys_get_priority())
}
/// Determine the priority of the current thread
#[inline(always)]
pub unsafe fn set_priority(tid: Tid, prio: Priority) {
sys_set_priority(tid, prio.into());
}

13
vendor/hermit-abi/src/tcplistener.rs vendored Normal file
View File

@ -0,0 +1,13 @@
//! `tcplistener` provide an interface to establish tcp socket server.
use crate::{Handle, IpAddress};
extern "Rust" {
fn sys_tcp_listener_accept(port: u16) -> Result<(Handle, IpAddress, u16), ()>;
}
/// Wait for connection at specified address.
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn accept(port: u16) -> Result<(Handle, IpAddress, u16), ()> {
unsafe { sys_tcp_listener_accept(port) }
}

110
vendor/hermit-abi/src/tcpstream.rs vendored Normal file
View File

@ -0,0 +1,110 @@
//! `tcpstream` provide an interface to establish tcp socket client.
use crate::{Handle, IpAddress};
extern "Rust" {
fn sys_tcp_stream_connect(ip: &[u8], port: u16, timeout: Option<u64>) -> Result<Handle, ()>;
fn sys_tcp_stream_close(handle: Handle) -> Result<(), ()>;
fn sys_tcp_stream_read(handle: Handle, buffer: &mut [u8]) -> Result<usize, ()>;
fn sys_tcp_stream_write(handle: Handle, buffer: &[u8]) -> Result<usize, ()>;
fn sys_tcp_stream_set_read_timeout(handle: Handle, timeout: Option<u64>) -> Result<(), ()>;
fn sys_tcp_stream_get_read_timeout(handle: Handle) -> Result<Option<u64>, ()>;
fn sys_tcp_stream_set_write_timeout(handle: Handle, timeout: Option<u64>) -> Result<(), ()>;
fn sys_tcp_stream_get_write_timeout(handle: Handle) -> Result<Option<u64>, ()>;
fn sys_tcp_stream_peek(handle: Handle, buf: &mut [u8]) -> Result<usize, ()>;
fn sys_tcp_stream_set_nonblocking(handle: Handle, mode: bool) -> Result<(), ()>;
fn sys_tcp_stream_set_tll(handle: Handle, ttl: u32) -> Result<(), ()>;
fn sys_tcp_stream_get_tll(handle: Handle) -> Result<u32, ()>;
fn sys_tcp_stream_shutdown(handle: Handle, how: i32) -> Result<(), ()>;
fn sys_tcp_stream_peer_addr(handle: Handle) -> Result<(IpAddress, u16), ()>;
}
/// Opens a TCP connection to a remote host.
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn connect(ip: &[u8], port: u16, timeout: Option<u64>) -> Result<Handle, ()> {
unsafe { sys_tcp_stream_connect(ip, port, timeout) }
}
/// Close a TCP connection
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn close(handle: Handle) -> Result<(), ()> {
unsafe { sys_tcp_stream_close(handle) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn peek(handle: Handle, buf: &mut [u8]) -> Result<usize, ()> {
unsafe { sys_tcp_stream_peek(handle, buf) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn peer_addr(handle: Handle) -> Result<(IpAddress, u16), ()> {
unsafe { sys_tcp_stream_peer_addr(handle) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn read(handle: Handle, buffer: &mut [u8]) -> Result<usize, ()> {
unsafe { sys_tcp_stream_read(handle, buffer) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn write(handle: Handle, buffer: &[u8]) -> Result<usize, ()> {
unsafe { sys_tcp_stream_write(handle, buffer) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn set_read_timeout(handle: Handle, timeout: Option<u64>) -> Result<(), ()> {
unsafe { sys_tcp_stream_set_read_timeout(handle, timeout) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn set_write_timeout(handle: Handle, timeout: Option<u64>) -> Result<(), ()> {
unsafe { sys_tcp_stream_set_write_timeout(handle, timeout) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn get_read_timeout(handle: Handle) -> Result<Option<u64>, ()> {
unsafe { sys_tcp_stream_get_read_timeout(handle) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn get_write_timeout(handle: Handle) -> Result<Option<u64>, ()> {
unsafe { sys_tcp_stream_get_write_timeout(handle) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn set_nodelay(_: Handle, mode: bool) -> Result<(), ()> {
// smoltcp does not support Nagle's algorithm
// => to enable Nagle's algorithm isn't possible
if mode {
Ok(())
} else {
Err(())
}
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn nodelay(_: Handle) -> Result<bool, ()> {
// smoltcp does not support Nagle's algorithm
// => return always true
Ok(true)
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn set_nonblocking(handle: Handle, mode: bool) -> Result<(), ()> {
unsafe { sys_tcp_stream_set_nonblocking(handle, mode) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn set_tll(handle: Handle, ttl: u32) -> Result<(), ()> {
unsafe { sys_tcp_stream_set_tll(handle, ttl) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn get_tll(handle: Handle) -> Result<u32, ()> {
unsafe { sys_tcp_stream_get_tll(handle) }
}
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn shutdown(handle: Handle, how: i32) -> Result<(), ()> {
unsafe { sys_tcp_stream_shutdown(handle, how) }
}