refactor: streamline realm checking in proxy and user authentication

Author: shenjinti

config.toml.example

@@ -40,14 +40,15 @@ method = "POST"
 mode = "auto"
 rtp_start_port = 20000
 rtp_end_port = 30000
+
 # external_ip = "192.168.1.1"  # Set to your external IP
 # force_proxy = ["192.168.1.100"]  # Optional: IP addresses to always proxy
 
 [proxy.user_backend]
 type = "memory"
 users = [
     { username = "bob", password = "123456", realm = "127.0.0.1" },
-    { username = "alice", password = "123456", realm = "127.0.0.1" },
+    { username = "alice", password = "123456" },
 ]
 
 [callrecord]

src/config.rs

@@ -253,25 +253,6 @@ impl ProxyConfig {
             realm
         }
     }
-    pub fn is_same_realm(&self, callee_realm: &str) -> bool {
-        match callee_realm {
-            "localhost" | "127.0.0.1" | "::1" => true,
-            _ => {
-                if let Some(external_ip) = self.external_ip.as_ref() {
-                    return external_ip.starts_with(callee_realm);
-                }
-                if let Some(realms) = self.realms.as_ref() {
-                    for item in realms {
-                        if item == callee_realm {
-                            return true;
-                        }
-                    }
-                }
-                false
-            }
-        }
-    }
-
     pub async fn route_invite(
         &self,
         option: InviteOption,

src/proxy/auth.rs

@@ -51,7 +51,7 @@ impl AuthModule {
                         return Ok(None);
                     }
                     if let Some(realm) = user.realm.as_ref() {
-                        if !self.server.config.is_same_realm(realm) {
+                        if !self.server.is_same_realm(realm).await {
                             info!(username = user.username, realm = ?user.realm, "User is not in the same realm");
                             return Ok(None);
                         }

src/proxy/call.rs

@@ -120,7 +120,7 @@ impl CallModule {
         let callee = callee_uri.user().unwrap_or_default().to_string();
         let callee_realm = callee_uri.host().to_string();
 
-        let target_locations = if !self.inner.config.is_same_realm(&callee_realm) {
+        let target_locations = if !self.inner.server.is_same_realm(&callee_realm).await {
             info!(callee_realm, "Forwarding INVITE to external realm");
             vec![Location {
                 aor: callee_uri.clone(),

src/proxy/server.rs

@@ -452,3 +452,24 @@ impl Drop for SipServerInner {
         info!("SipServerInner dropped");
     }
 }
+
+impl SipServerInner {
+    pub async fn is_same_realm(&self, callee_realm: &str) -> bool {
+        match callee_realm {
+            "localhost" | "127.0.0.1" | "::1" => true,
+            _ => {
+                if let Some(external_ip) = self.config.external_ip.as_ref() {
+                    return external_ip.starts_with(callee_realm);
+                }
+                if let Some(realms) = self.config.realms.as_ref() {
+                    for item in realms {
+                        if item == callee_realm {
+                            return true;
+                        }
+                    }
+                }
+                self.user_backend.is_same_realm(callee_realm).await
+            }
+        }
+    }
+}

src/proxy/user.rs

@@ -181,6 +181,7 @@ pub trait UserBackend: Send + Sync {
             user.to_string()
         }
     }
+    async fn is_same_realm(&self, realm: &str) -> bool;
     async fn get_user(&self, username: &str, realm: Option<&str>) -> Result<SipUser>;
     async fn create_user(&self, _user: SipUser) -> Result<()> {
         Ok(())
@@ -283,6 +284,10 @@ impl MemoryUserBackend {
 
 #[async_trait]
 impl UserBackend for MemoryUserBackend {
+    async fn is_same_realm(&self, realm: &str) -> bool {
+        return realm.is_empty();
+    }
+
     fn get_identifier(&self, user: &str, realm: Option<&str>) -> String {
         Self::get_identifier(user, realm)
     }
@@ -292,7 +297,18 @@ impl UserBackend for MemoryUserBackend {
         let identifier = self.get_identifier(username, realm);
         let mut user = match users.get(&identifier) {
             Some(user) => user.clone(),
-            None => return Err(anyhow::anyhow!("missing user: {}", identifier)),
+            None => {
+                match users.get(username) {
+                    Some(user) => {
+                        if user.realm.as_ref().is_some_and(|r| !r.is_empty()) {
+                            return Err(anyhow::anyhow!("missing user: {}", identifier));
+                        }
+                        return Ok(user.clone());
+                    }
+                    None => {}
+                }
+                return Err(anyhow::anyhow!("missing user: {}", identifier));
+            }
         };
         user.realm = realm.map(|r| r.to_string());
         Ok(user)

src/proxy/user_db.rs

@@ -42,6 +42,23 @@ impl DbBackend {
 
 #[async_trait]
 impl UserBackend for DbBackend {
+    async fn is_same_realm(&self, realm: &str) -> bool {
+        if let Some(ref realm_col) = self.realm_column {
+            let query = format!(
+                "SELECT COUNT(*) FROM {} WHERE  {} = ?",
+                self.table_name, realm_col
+            );
+            let count = sqlx::query(&query)
+                .bind(realm)
+                .fetch_one(&self.db)
+                .await
+                .map_err(|e| anyhow!("Database query error: {}", e))
+                .map(|row| row.get(0))
+                .unwrap_or(0);
+            return count > 0;
+        }
+        false
+    }
     async fn get_user(&self, username: &str, realm: Option<&str>) -> Result<SipUser> {
         // Build SELECT clause with optional columns
         let mut select_columns = vec![self.username_column.clone(), self.password_column.clone()];

src/proxy/user_http.rs

@@ -53,6 +53,9 @@ impl HttpUserBackend {
 
 #[async_trait]
 impl UserBackend for HttpUserBackend {
+    async fn is_same_realm(&self, realm: &str) -> bool {
+        self.get_user("", Some(realm)).await.is_ok()
+    }
     async fn get_user(&self, username: &str, realm: Option<&str>) -> Result<SipUser> {
         let start_time = Instant::now();
         let mut request_builder = match self.method {

src/proxy/user_plain.rs

@@ -70,19 +70,16 @@ impl PlainTextBackend {
 
 #[async_trait]
 impl UserBackend for PlainTextBackend {
+    async fn is_same_realm(&self, realm: &str) -> bool {
+        return realm.is_empty();
+    }
     async fn get_user(&self, username: &str, realm: Option<&str>) -> Result<SipUser> {
-        let key = if let Some(realm) = realm {
-            format!("{}@{}", username, realm)
-        } else {
-            username.to_string()
-        };
-
-        let mut user = match self.users.lock().unwrap().get(&key) {
+        let mut user = match self.users.lock().unwrap().get(username) {
             Some(user) => user.clone(),
-            None => return Err(anyhow::anyhow!("missing user: {}", key)),
+            None => return Err(anyhow::anyhow!("missing user: {}", username)),
         };
         if !user.enabled {
-            return Err(anyhow::anyhow!("User is disabled: {}", key));
+            return Err(anyhow::anyhow!("User is disabled: {}", username));
         }
         user.realm = realm.map(|r| r.to_string());
         Ok(user)

static/phone.html

@@ -235,7 +235,7 @@ <h3>Logs</h3>
 
         function log(message) {
             const timestamp = new Date().toLocaleTimeString();
-            logs.innerHTML += `[${timestamp}] ${message}\n`;
+            logs.innerHTML += `[${timestamp}] ${message}<br>`;
             logs.scrollTop = logs.scrollHeight;
             console.log(message);
         }