488 lines
14 KiB
Rust
488 lines
14 KiB
Rust
//! Networking library
|
|
//!
|
|
//! The `lb:net` library provides an asynchronous network API for creating TCP or UDP servers and
|
|
//! clients.
|
|
//!
|
|
//! ## Exports
|
|
//!
|
|
//! See [`lb_netlib`] for items exported by this library.
|
|
use derive_more::{From, FromStr};
|
|
use luaffi::{cdef, metatype};
|
|
use std::{
|
|
net::{AddrParseError, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
|
|
time::Duration,
|
|
};
|
|
use thiserror::Error;
|
|
use tokio::net::{TcpListener, TcpSocket, TcpStream};
|
|
|
|
/// Errors that can be thrown by this library.
|
|
///
|
|
/// Functions which return this error will **throw** in Lua. The error message can be caught by
|
|
/// using [`pcall(f, ...)`](https://www.lua.org/manual/5.1/manual.html#pdf-pcall).
|
|
#[derive(Debug, Error)]
|
|
pub enum Error {
|
|
/// I/O error.
|
|
#[error("{0}")]
|
|
Io(#[from] std::io::Error),
|
|
/// IP or socket address syntax error.
|
|
#[error("{0}")]
|
|
InvalidAddr(#[from] AddrParseError),
|
|
/// Socket was already converted and cannot be used anymore.
|
|
#[error("socket was already converted")]
|
|
SocketConsumed,
|
|
}
|
|
|
|
type Result<T> = std::result::Result<T, Error>;
|
|
|
|
/// Items exported by the `lb:net` library.
|
|
///
|
|
/// This library can be acquired by calling
|
|
/// [`require("lb:net")`](https://www.lua.org/manual/5.1/manual.html#pdf-require) in Lua.
|
|
///
|
|
/// ```lua
|
|
/// local net = require("lb:net");
|
|
/// ```
|
|
#[cdef(module = "lb:net")]
|
|
pub struct lb_netlib;
|
|
|
|
#[metatype]
|
|
impl lb_netlib {
|
|
#[new]
|
|
extern "Lua-C" fn new() -> Self {
|
|
Self
|
|
}
|
|
|
|
/// See [`Ipv4Addr::LOCALHOST`].
|
|
pub extern "Lua-C" fn localhost_v4(&self) -> lb_ipaddr {
|
|
lb_ipaddr(Ipv4Addr::LOCALHOST.into())
|
|
}
|
|
|
|
/// See [`Ipv6Addr::LOCALHOST`].
|
|
pub extern "Lua-C" fn localhost_v6(&self) -> lb_ipaddr {
|
|
lb_ipaddr(Ipv6Addr::LOCALHOST.into())
|
|
}
|
|
|
|
/// See [`Ipv4Addr::UNSPECIFIED`].
|
|
pub extern "Lua-C" fn unspecified_v4(&self) -> lb_ipaddr {
|
|
lb_ipaddr(Ipv4Addr::UNSPECIFIED.into())
|
|
}
|
|
|
|
/// See [`Ipv6Addr::UNSPECIFIED`].
|
|
pub extern "Lua-C" fn unspecified_v6(&self) -> lb_ipaddr {
|
|
lb_ipaddr(Ipv6Addr::UNSPECIFIED.into())
|
|
}
|
|
|
|
/// See [`Ipv4Addr::BROADCAST`].
|
|
pub extern "Lua-C" fn broadcast_v4(&self) -> lb_ipaddr {
|
|
lb_ipaddr(Ipv4Addr::BROADCAST.into())
|
|
}
|
|
|
|
/// Creates an [`lb_ipaddr`] from the given input.
|
|
///
|
|
/// If `s` is an [`lb_ipaddr`], a copy of that value is returned. If `s` is an
|
|
/// [`lb_socketaddr`], the IP address part of the socket address is returned. Otherwise, parses
|
|
/// `s` as an IP address string. Both IPv4 or IPv6 addresses are supported.
|
|
pub extern "Lua" fn ipaddr(&self, s: any) -> Result<lb_ipaddr> {
|
|
if __istype(__ct.lb_ipaddr, s) {
|
|
__new(__ct.lb_ipaddr, s) // copy constructor
|
|
} else if __istype(__ct.lb_socketaddr, s) {
|
|
s.ip()
|
|
} else {
|
|
self.__parse_ipaddr(s)
|
|
}
|
|
}
|
|
|
|
extern "Lua-C" fn __parse_ipaddr(&self, s: &str) -> Result<lb_ipaddr> {
|
|
Ok(s.parse()?)
|
|
}
|
|
|
|
/// Creates an [`lb_socketaddr`] from the given input.
|
|
///
|
|
/// A socket address is an IP address with a port number.
|
|
///
|
|
/// If `s` is an [`lb_socketaddr`], a copy of that value is returned. If `s` is an
|
|
/// [`lb_ipaddr`], a socket address with that IP address is returned. Otherwise, parses `s` as a
|
|
/// socket address string. Both IPv4 and IPv6 addresses are supported.
|
|
///
|
|
/// If `port` is not specified, `0` is used as the default.
|
|
pub extern "Lua" fn socketaddr(&self, s: any, port: any) -> Result<lb_socketaddr> {
|
|
if port != () {
|
|
self.__new_skaddr(self.ipaddr(s), port)
|
|
} else {
|
|
if __istype(__ct.lb_socketaddr, s) {
|
|
__new(__ct.lb_socketaddr, s) // copy constructor
|
|
} else if __istype(__ct.lb_ipaddr, s) {
|
|
self.__new_skaddr(s, 0) // default port 0
|
|
} else {
|
|
self.__parse_skaddr(s)
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "Lua-C" fn __new_skaddr(&self, ip: &lb_ipaddr, port: u16) -> lb_socketaddr {
|
|
SocketAddr::new(ip.0, port).into()
|
|
}
|
|
|
|
extern "Lua-C" fn __parse_skaddr(&self, s: &str) -> Result<lb_socketaddr> {
|
|
Ok(s.parse()?)
|
|
}
|
|
|
|
/// Creates a new TCP socket configured for IPv4.
|
|
///
|
|
/// See [`TcpSocket::new_v4`].
|
|
pub extern "Lua-C" fn tcp(&self) -> Result<lb_tcpsocket> {
|
|
Ok(Some(TcpSocket::new_v4()?).into())
|
|
}
|
|
|
|
/// Creates a new TCP socket configured for IPv6.
|
|
///
|
|
/// See [`TcpSocket::new_v6`].
|
|
pub extern "Lua-C" fn tcp6(&self) -> Result<lb_tcpsocket> {
|
|
Ok(Some(TcpSocket::new_v6()?).into())
|
|
}
|
|
|
|
pub async extern "Lua" fn bind_tcp(&self, addr: any, port: any) -> Result<lb_tcpsocket> {
|
|
let addr = self.socketaddr(addr, port);
|
|
let socket;
|
|
if addr.ip().is_v6() {
|
|
socket = self.tcp6();
|
|
} else {
|
|
socket = self.tcp();
|
|
}
|
|
socket.bind(addr);
|
|
socket
|
|
}
|
|
|
|
pub async extern "Lua" fn connect_tcp(&self, addr: any, port: any) -> Result<lb_tcpstream> {
|
|
let addr = self.socketaddr(addr, port);
|
|
let socket;
|
|
if addr.ip().is_v6() {
|
|
socket = self.tcp6();
|
|
} else {
|
|
socket = self.tcp();
|
|
}
|
|
socket.connect(addr)
|
|
}
|
|
|
|
pub async extern "Lua" fn listen_tcp(&self, addr: any, port: any) -> Result<lb_tcplistener> {
|
|
self.bind_tcp(addr, port).listen(1024)
|
|
}
|
|
}
|
|
|
|
/// IP address, either IPv4 or IPv6.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// This example creates an [`lb_ipaddr`] by parsing an IP address string.
|
|
///
|
|
/// ```lua
|
|
/// local net = require("lb:net");
|
|
/// local addr = net:ipaddr("127.0.0.1"); -- ipv4 loopback address
|
|
///
|
|
/// assert(addr:is_v4());
|
|
/// assert(addr:is_loopback());
|
|
/// ```
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, From, FromStr)]
|
|
#[cdef]
|
|
pub struct lb_ipaddr(#[opaque] IpAddr);
|
|
|
|
#[metatype]
|
|
impl lb_ipaddr {
|
|
/// See [`IpAddr::is_unspecified`].
|
|
pub extern "Lua-C" fn is_unspecified(&self) -> bool {
|
|
self.0.is_unspecified()
|
|
}
|
|
|
|
/// See [`IpAddr::is_loopback`].
|
|
pub extern "Lua-C" fn is_loopback(&self) -> bool {
|
|
self.0.is_loopback()
|
|
}
|
|
|
|
/// See [`IpAddr::is_multicast`].
|
|
pub extern "Lua-C" fn is_multicast(&self) -> bool {
|
|
self.0.is_multicast()
|
|
}
|
|
|
|
/// Returns the string `"v4"` if this is an IPv4 address or `"v6"` if this is an IPv6 address.
|
|
pub extern "Lua" fn family(&self) -> string {
|
|
if self.is_v6() { "v6" } else { "v4" }
|
|
}
|
|
|
|
/// Returns `true` if this is an IPv4 address.
|
|
pub extern "Lua-C" fn is_v4(&self) -> bool {
|
|
self.0.is_ipv4()
|
|
}
|
|
|
|
/// See [`Ipv4Addr::is_private`].
|
|
pub extern "Lua-C" fn is_v4_private(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => v4.is_private(),
|
|
IpAddr::V6(_) => false,
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv4Addr::is_link_local`].
|
|
pub extern "Lua-C" fn is_v4_link_local(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => v4.is_link_local(),
|
|
IpAddr::V6(_) => false,
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv4Addr::is_broadcast`].
|
|
pub extern "Lua-C" fn is_v4_broadcast(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => v4.is_broadcast(),
|
|
IpAddr::V6(_) => false,
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv4Addr::is_documentation`].
|
|
pub extern "Lua-C" fn is_v4_documentation(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => v4.is_documentation(),
|
|
IpAddr::V6(_) => false,
|
|
}
|
|
}
|
|
|
|
/// Returns `true` if this is an IPv6 address.
|
|
pub extern "Lua-C" fn is_v6(&self) -> bool {
|
|
self.0.is_ipv6()
|
|
}
|
|
|
|
/// See [`Ipv6Addr::is_unique_local`].
|
|
pub extern "Lua-C" fn is_v6_unique_local(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(_) => false,
|
|
IpAddr::V6(v6) => v6.is_unique_local(),
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv6Addr::is_unicast_link_local`].
|
|
pub extern "Lua-C" fn is_v6_unicast_link_local(&self) -> bool {
|
|
match self.0 {
|
|
IpAddr::V4(_) => false,
|
|
IpAddr::V6(v6) => v6.is_unicast_link_local(),
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv4Addr::to_ipv6_compatible`].
|
|
pub extern "Lua-C" fn to_v6_compat(&self) -> Self {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => Self(v4.to_ipv6_compatible().into()),
|
|
IpAddr::V6(_) => *self,
|
|
}
|
|
}
|
|
|
|
/// See [`Ipv4Addr::to_ipv6_mapped`].
|
|
pub extern "Lua-C" fn to_v6_mapped(&self) -> Self {
|
|
match self.0 {
|
|
IpAddr::V4(v4) => Self(v4.to_ipv6_mapped().into()),
|
|
IpAddr::V6(_) => *self,
|
|
}
|
|
}
|
|
|
|
/// See [`IpAddr::to_canonical`].
|
|
pub extern "Lua-C" fn canonical(&self) -> Self {
|
|
self.0.to_canonical().into()
|
|
}
|
|
|
|
/// Returns the string representation of this address.
|
|
#[tostring]
|
|
pub extern "Lua-C" fn tostring(&self) -> String {
|
|
self.0.to_string()
|
|
}
|
|
}
|
|
|
|
/// Socket address, which is an IP address with a port number.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, From, FromStr)]
|
|
#[cdef]
|
|
pub struct lb_socketaddr(#[opaque] SocketAddr);
|
|
|
|
#[metatype]
|
|
impl lb_socketaddr {
|
|
/// Returns the IP part of this address.
|
|
pub extern "Lua-C" fn ip(&self) -> lb_ipaddr {
|
|
self.0.ip().into()
|
|
}
|
|
|
|
/// Sets the IP part of this address.
|
|
///
|
|
/// This function accepts the same arguments as [`ipaddr`](lb_netlib::ipaddr).
|
|
pub extern "Lua" fn set_ip(&mut self, s: any) -> &mut Self {
|
|
if __istype(__ct.lb_ipaddr, s) {
|
|
self.__set_ip(s);
|
|
} else if __istype(__ct.lb_socketaddr, s) {
|
|
self.__set_ip(s.ip());
|
|
} else {
|
|
self.__set_ip_parse(s);
|
|
}
|
|
self
|
|
}
|
|
|
|
extern "Lua-C" fn __set_ip(&mut self, ip: &lb_ipaddr) {
|
|
self.0.set_ip(ip.0);
|
|
}
|
|
|
|
extern "Lua-C" fn __set_ip_parse(&mut self, s: &str) -> Result<()> {
|
|
Ok(self.0.set_ip(s.parse()?))
|
|
}
|
|
|
|
/// Returns the port part of this address.
|
|
pub extern "Lua-C" fn port(&self) -> u16 {
|
|
self.0.port()
|
|
}
|
|
|
|
/// Sets the port part of this address.
|
|
pub extern "Lua" fn set_port(&mut self, port: integer) -> &mut Self {
|
|
self.__set_port(port);
|
|
self
|
|
}
|
|
|
|
extern "Lua-C" fn __set_port(&mut self, port: u16) {
|
|
self.0.set_port(port)
|
|
}
|
|
|
|
/// Returns the string representation of this address.
|
|
#[tostring]
|
|
pub extern "Lua-C" fn tostring(&self) -> String {
|
|
self.0.to_string()
|
|
}
|
|
}
|
|
|
|
/// TCP socket which has not yet been converted to an [`lb_tcpstream`] or [`lb_tcplistener`].
|
|
#[derive(Debug, From)]
|
|
#[cdef]
|
|
pub struct lb_tcpsocket(#[opaque] Option<TcpSocket>);
|
|
|
|
#[metatype]
|
|
impl lb_tcpsocket {
|
|
fn socket(&self) -> Result<&TcpSocket> {
|
|
self.0.as_ref().ok_or(Error::SocketConsumed)
|
|
}
|
|
|
|
/// See [`TcpSocket::keepalive`].
|
|
pub extern "Lua-C" fn keepalive(&self) -> Result<bool> {
|
|
Ok(self.socket()?.keepalive()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_keepalive`].
|
|
pub extern "Lua-C" fn set_keepalive(&self, enabled: bool) -> Result<()> {
|
|
Ok(self.socket()?.set_keepalive(enabled)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::reuseaddr`].
|
|
pub extern "Lua-C" fn reuseaddr(&self) -> Result<bool> {
|
|
Ok(self.socket()?.reuseaddr()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_reuseaddr`].
|
|
pub extern "Lua-C" fn set_reuseaddr(&self, enabled: bool) -> Result<()> {
|
|
Ok(self.socket()?.set_reuseaddr(enabled)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::reuseport`].
|
|
pub extern "Lua-C" fn reuseport(&self) -> Result<bool> {
|
|
Ok(self.socket()?.reuseport()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_reuseport`].
|
|
pub extern "Lua-C" fn set_reuseport(&self, enabled: bool) -> Result<()> {
|
|
Ok(self.socket()?.set_reuseport(enabled)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::send_buffer_size`].
|
|
pub extern "Lua-C" fn sendbuf(&self) -> Result<u32> {
|
|
Ok(self.socket()?.send_buffer_size()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_send_buffer_size`].
|
|
pub extern "Lua-C" fn set_sendbuf(&self, size: u32) -> Result<()> {
|
|
Ok(self.socket()?.set_send_buffer_size(size)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::recv_buffer_size`].
|
|
pub extern "Lua-C" fn recvbuf(&self) -> Result<u32> {
|
|
Ok(self.socket()?.recv_buffer_size()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_recv_buffer_size`].
|
|
pub extern "Lua-C" fn set_recvbuf(&self, size: u32) -> Result<()> {
|
|
Ok(self.socket()?.set_recv_buffer_size(size)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::linger`].
|
|
pub extern "Lua-C" fn linger(&self) -> Result<f64> {
|
|
Ok(self
|
|
.socket()?
|
|
.linger()?
|
|
.map(|n| n.as_secs_f64())
|
|
.unwrap_or(0.))
|
|
}
|
|
|
|
/// See [`TcpSocket::set_linger`].
|
|
pub extern "Lua-C" fn set_linger(&self, secs: f64) -> Result<()> {
|
|
Ok(self
|
|
.socket()?
|
|
.set_linger((secs != 0.).then_some(Duration::from_secs_f64(secs)))?)
|
|
}
|
|
|
|
/// See [`TcpSocket::nodelay`].
|
|
pub extern "Lua-C" fn nodelay(&self) -> Result<bool> {
|
|
Ok(self.socket()?.nodelay()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_nodelay`].
|
|
pub extern "Lua-C" fn set_nodelay(&self, enabled: bool) -> Result<()> {
|
|
Ok(self.socket()?.set_nodelay(enabled)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::tos`].
|
|
pub extern "Lua-C" fn tos(&self) -> Result<u32> {
|
|
Ok(self.socket()?.tos()?)
|
|
}
|
|
|
|
/// See [`TcpSocket::set_tos`].
|
|
pub extern "Lua-C" fn set_tos(&self, tos: u32) -> Result<()> {
|
|
Ok(self.socket()?.set_tos(tos)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::local_addr`].
|
|
pub extern "Lua-C" fn local_addr(&self) -> Result<lb_socketaddr> {
|
|
Ok(self.socket()?.local_addr()?.into())
|
|
}
|
|
|
|
/// See [`TcpSocket::bind`].
|
|
pub extern "Lua-C" fn bind(&self, addr: &lb_socketaddr) -> Result<()> {
|
|
Ok(self.socket()?.bind(addr.0)?)
|
|
}
|
|
|
|
/// See [`TcpSocket::connect`].
|
|
pub async extern "Lua-C" fn connect(&mut self, addr: &lb_socketaddr) -> Result<lb_tcpstream> {
|
|
let socket = self.0.take().ok_or(Error::SocketConsumed)?;
|
|
Ok(socket.connect(addr.0).await?.into())
|
|
}
|
|
|
|
/// See [`TcpSocket::listen`].
|
|
pub extern "Lua-C" fn listen(&mut self, backlog: u32) -> Result<lb_tcplistener> {
|
|
let socket = self.0.take().ok_or(Error::SocketConsumed)?;
|
|
Ok(socket.listen(backlog)?.into())
|
|
}
|
|
}
|
|
|
|
/// TCP connection between a local and a remote socket.
|
|
#[derive(Debug, From)]
|
|
#[cdef]
|
|
pub struct lb_tcpstream(#[opaque] TcpStream);
|
|
|
|
#[metatype]
|
|
impl lb_tcpstream {}
|
|
|
|
/// TCP socket server, listening for connections.
|
|
#[derive(Debug, From)]
|
|
#[cdef]
|
|
pub struct lb_tcplistener(#[opaque] TcpListener);
|
|
|
|
#[metatype]
|
|
impl lb_tcplistener {}
|