✨ support domain names

Author: hronro

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - [CHANGELOG.md](https://github.com/hronro/iPortForwarder/blob/master/CHANGELOG.md). All the notable changes will be documented in this file from this release.
 - Enable [App Sandbox](https://developer.apple.com/documentation/security/app-sandbox) for better security.
+- Allow using domain names (previously only IP addresses were allowed). Also an icon is added to indicate the type of the address.
 
 ### Changed
 

core/demo.lua

@@ -22,25 +22,25 @@ local function check_ip_is_valid(ip)
 	return ipf.ipf_check_ip_is_valid(ffi.new('char [?]', #ip + 1, ip))
 end
 
----Forward ip and port
----@param ip string
+---Forward address and port
+---@param address string
 ---@param remote_port number
 ---@param local_port number
 ---@param allow_lan boolean
 ---@return number forward_rule_id
-local function forward(ip, remote_port, local_port, allow_lan)
-	return ipf.ipf_forward(ffi.new('char [?]', #ip + 1, ip), remote_port, local_port, allow_lan)
+local function forward(address, remote_port, local_port, allow_lan)
+	return ipf.ipf_forward(ffi.new('char [?]', #address + 1, address), remote_port, local_port, allow_lan)
 end
 
----Forward ip and a range of ports
----@param ip string
+---Forward address and a range of ports
+---@param address string
 ---@param remote_port_start number
 ---@param remote_port_end number
 ---@param local_port_start number
 ---@param allow_lan boolean
 ---@return number forward_rule_id
-local function forward_range(ip, remote_port_start, remote_port_end, local_port_start, allow_lan)
-	return ipf.ipf_forward_range(ffi.new('char [?]', #ip + 1, ip), remote_port_start, remote_port_end, local_port_start, allow_lan)
+local function forward_range(address, remote_port_start, remote_port_end, local_port_start, allow_lan)
+	return ipf.ipf_forward_range(ffi.new('char [?]', #address + 1, address), remote_port_start, remote_port_end, local_port_start, allow_lan)
 end
 
 ---Cancel forward
@@ -57,17 +57,18 @@ local function error_message(error)
 	local message_table = {
 		[-1] = 'Unknown error',
 		[-10] = 'Invalid string',
-		[-11] = 'Invalid IP address',
-		[-12] = 'Too many rules',
-		[-13] = 'Invalid rule ID',
-		[-14] = 'Invalid local start port',
-		[-15] = 'Invalid remote end port',
-		[-16] = 'Error handler is already registered',
+		[-11] = 'Too many rules',
+		[-12] = 'Invalid rule ID',
+		[-13] = 'Invalid local start port',
+		[-14] = 'Invalid remote end port',
+		[-15] = 'Error handler is already registered',
 		[-51] = 'Permission denied',
 		[-52] = 'Address in use',
 		[-53] = 'Already exists',
 		[-54] = 'Out of memory',
 		[-55] = 'Too many open files',
+		[-56] = 'Address can not be resolved',
+
 	}
 
 	return message_table[error]
@@ -126,9 +127,10 @@ print 'Please input IP address you want to forward:'
 
 local ip = io.read()
 
-if check_ip_is_valid(ip) == false then
-	print("IP address " .. ip .. " is invalid.")
-	os.exit(1)
+if check_ip_is_valid(ip) then
+	print 'Detecting IP address, skip DNS lockup.'
+else
+	print 'Detecting domian name, performing DNS lockup...'
 end
 
 print 'Please input how long (in seconds, empty means forever) you want to forward:'
@@ -149,6 +151,11 @@ else
 	os.exit(1)
 end
 
+if forward_rule_id < 0 then
+	print('Error: ' .. error_message(forward_rule_id))
+	os.exit(1)
+end
+
 print 'Forwarding started.'
 
 if time ~= nil then

core/src/error.rs

@@ -10,24 +10,21 @@ pub enum Error {
     /// Invalid C format string.
     InvalidString = -10,
 
-    /// The IP address is invalid.
-    InvalidIpAddr = -11,
-
     /// At most 128 rules are allowed.
-    TooManyRules = -12,
+    TooManyRules = -11,
 
     /// The rule ID is invalid.
-    InvalidRuleId = -13,
+    InvalidRuleId = -12,
 
     /// The local port start is invalid,
     /// which will make the local port end greater than 65535.
-    InvalidLocalPortStart = -14,
+    InvalidLocalPortStart = -13,
 
     /// The remote port end is invalid.
-    InvalidRemotePortEnd = -15,
+    InvalidRemotePortEnd = -14,
 
     /// The error handler has already been registered.
-    HandlerAlreadyRegistered = -16,
+    HandlerAlreadyRegistered = -15,
 
     // OS errors, from -51 to -127.
     /// Permission denied.
@@ -45,6 +42,9 @@ pub enum Error {
 
     /// Too many open files.
     TooManyOpenFiles = -55,
+
+    /// Address can not be resolved.
+    AddressCantBeResolved = -56,
 }
 impl From<io::Error> for Error {
     fn from(io_error: io::Error) -> Self {

core/src/lib.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 use std::ffi::CStr;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, ToSocketAddrs};
 use std::os::raw::c_char;
 use std::sync::{LazyLock, Mutex, OnceLock};
 
@@ -87,21 +87,25 @@ pub extern "C" fn ipf_check_ip_is_valid(ip_c_string: *const c_char) -> bool {
 #[no_mangle]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn ipf_forward(
-    ip_c_string: *const c_char,
+    address_c_string: *const c_char,
     remote_port: u16,
     local_port: u16,
     allow_lan: bool,
 ) -> i8 {
+    println!("hi");
     if let Some(rule_id) = get_new_rule_id() {
-        let ip_str = unsafe {
-            match CStr::from_ptr(ip_c_string).to_str() {
-                Ok(ip_str) => ip_str,
+        let addr_str = unsafe {
+            match CStr::from_ptr(address_c_string).to_str() {
+                Ok(addr_str) => addr_str,
                 Err(_) => return Error::InvalidString as i8,
             }
         };
-        let ip: IpAddr = match ip_str.parse() {
-            Ok(ip) => ip,
-            Err(_) => return Error::InvalidIpAddr as i8,
+        let socket_addr = match addr_str.parse::<IpAddr>() {
+            Ok(ip) => SocketAddr::new(ip, remote_port),
+            Err(_) => match (addr_str, remote_port).to_socket_addrs() {
+                Ok(mut socket_addrs) => socket_addrs.next().unwrap(),
+                Err(_) => return Error::AddressCantBeResolved as i8,
+            },
         };
 
         let join_handler = RT.spawn(async move {
@@ -116,7 +120,7 @@ pub extern "C" fn ipf_forward(
                 Ok(listener) => loop {
                     if let Ok((mut ingress, _)) = listener.accept().await {
                         if let Ok(mut egress) =
-                            TcpStream::connect(SocketAddr::new(ip, remote_port)).await
+                            TcpStream::connect(socket_addr).await
                         {
                             RT.spawn(async move {
                                 _ = copy_bidirectional(&mut ingress, &mut egress).await;
@@ -147,7 +151,7 @@ pub extern "C" fn ipf_forward(
 #[no_mangle]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn ipf_forward_range(
-    ip_c_string: *const c_char,
+    address_c_string: *const c_char,
     remote_port_start: u16,
     remote_port_end: u16,
     local_port_start: u16,
@@ -162,15 +166,18 @@ pub extern "C" fn ipf_forward_range(
     }
 
     if let Some(rule_id) = get_new_rule_id() {
-        let ip_str = unsafe {
-            match CStr::from_ptr(ip_c_string).to_str() {
+        let addr_str = unsafe {
+            match CStr::from_ptr(address_c_string).to_str() {
                 Ok(ip_str) => ip_str,
                 Err(_) => return Error::InvalidString as i8,
             }
         };
-        let ip: IpAddr = match ip_str.parse() {
+        let ip = match addr_str.parse::<IpAddr>() {
             Ok(ip) => ip,
-            Err(_) => return Error::InvalidIpAddr as i8,
+            Err(_) => match (addr_str, 0).to_socket_addrs() {
+                Ok(mut socket_addrs) => socket_addrs.next().unwrap().ip(),
+                Err(_) => return Error::AddressCantBeResolved as i8,
+            },
         };
 
         let join_handlers = (remote_port_start..=remote_port_end)