refactor: replace socket2 with tokio::net::TcpSocket and enhance release notes generation

Author: missuo

.github/workflows/release.yml

@@ -80,6 +80,11 @@ jobs:
     needs: build
     runs-on: ubuntu-latest
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
       - name: Download all artifacts
         uses: actions/download-artifact@v4
         with:
@@ -99,8 +104,30 @@ jobs:
           done
           ls -la release/
 
+      - name: Generate release notes
+        id: release_notes
+        run: |
+          # Get the previous tag
+          PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+          CURRENT_TAG=${GITHUB_REF#refs/tags/}
+
+          echo "## What's Changed" > release_notes.md
+          echo "" >> release_notes.md
+
+          if [ -z "$PREV_TAG" ]; then
+            # First release, get all commits
+            git log --pretty=format:"- %s (%h)" >> release_notes.md
+          else
+            # Get commits between tags
+            git log --pretty=format:"- %s (%h)" ${PREV_TAG}..${CURRENT_TAG} >> release_notes.md
+          fi
+
+          echo "" >> release_notes.md
+          echo "" >> release_notes.md
+          echo "**Full Changelog**: https://github.com/${{ github.repository }}/compare/${PREV_TAG:-$(git rev-list --max-parents=0 HEAD)}...${CURRENT_TAG}" >> release_notes.md
+
       - name: Create Release
         uses: softprops/action-gh-release@v2
         with:
           files: release/*
-          generate_release_notes: true
+          body_path: release_notes.md

Cargo.lock

@@ -12,4 +12,3 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 ipnet = "2"
 rand = "0.8"
-socket2 = "0.5"

Cargo.toml

@@ -1,17 +1,13 @@
 use clap::Parser;
 use ipnet::IpNet;
 use rand::Rng;
-use socket2::{Domain, Protocol, Socket, Type};
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
 use std::sync::Arc;
 use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpSocket, TcpStream};
 use tracing::{error, info, warn};
 
-#[cfg(unix)]
-use std::os::unix::io::{FromRawFd, IntoRawFd};
-
 // SOCKS5 protocol constants
 const SOCKS_VERSION: u8 = 0x05;
 
@@ -342,39 +338,40 @@ async fn handle_request(stream: &mut TcpStream, config: &ServerConfig) -> Result
         let local_ip = random_ip_from_cidr(cidr);
         info!("Connecting to {} via {}", target, local_ip);
 
-        // Resolve target address (handles both IP and domain names)
-        let mut addrs = tokio::net::lookup_host(&target).await?;
-        let remote_addr = match local_ip {
-            IpAddr::V4(_) => addrs.find(|a| a.is_ipv4()),
-            IpAddr::V6(_) => addrs.find(|a| a.is_ipv6()),
-        };
-
-        match remote_addr {
-            Some(addr) => {
-                let domain = match local_ip {
-                    IpAddr::V4(_) => Domain::IPV4,
-                    IpAddr::V6(_) => Domain::IPV6,
-                };
-                let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
-
-                // Enable IP_FREEBIND to bind to addresses not yet configured on the interface
-                #[cfg(target_os = "linux")]
-                socket.set_freebind(true)?;
-
-                socket.bind(&SocketAddr::new(local_ip, 0).into())?;
-                socket.set_nonblocking(true)?;
-
-                // Convert socket2::Socket to tokio::TcpSocket via raw fd
-                #[cfg(unix)]
-                let tcp_socket = unsafe { TcpSocket::from_raw_fd(socket.into_raw_fd()) };
-
-                tcp_socket.connect(addr).await
-            }
-            None => {
-                // Fallback: try to connect without binding if no matching address family
-                warn!("No matching address family for {}, connecting without bind", target);
-                TcpStream::connect(&target).await
+        // Resolve target address and try to connect
+        match target.to_socket_addrs() {
+            Ok(addrs) => {
+                let mut last_err = None;
+                let mut connected = None;
+
+                for addr in addrs {
+                    // Create socket matching the local IP family
+                    let socket = match local_ip {
+                        IpAddr::V4(_) if addr.is_ipv4() => TcpSocket::new_v4()?,
+                        IpAddr::V6(_) if addr.is_ipv6() => TcpSocket::new_v6()?,
+                        _ => continue, // Skip if address family doesn't match
+                    };
+
+                    let bind_addr = SocketAddr::new(local_ip, 0);
+                    if socket.bind(bind_addr).is_ok() {
+                        match socket.connect(addr).await {
+                            Ok(stream) => {
+                                connected = Some(stream);
+                                break;
+                            }
+                            Err(e) => last_err = Some(e),
+                        }
+                    }
+                }
+
+                match connected {
+                    Some(stream) => Ok(stream),
+                    None => Err(last_err.unwrap_or_else(|| {
+                        std::io::Error::new(std::io::ErrorKind::Other, "No matching address family")
+                    })),
+                }
             }
+            Err(e) => Err(e),
         }
     } else {
         info!("Connecting to {}", target);