SIP Server with Mobicents in Java

Overview

Mobicents is an open-source Java-based SIP (Session Initiation Protocol) server that provides VoIP and real-time communication capabilities. It's part of the Restcomm project and supports SIP servlets for building telecom applications.

1. Setup and Dependencies

Maven Dependencies

<!-- pom.xml --> <properties> <mobicents.version>3.0.0.FINAL</mobicents.version> <sip.servlet.version>3.0.0.FINAL</sip.servlet.version> </properties> <dependencies> <!-- Mobicents SIP Servlets --> <dependency> <groupId>org.mobicents.servlet.sip</groupId> <artifactId>sip-servlets-core-api</artifactId> <version>${sip.servlet.version}</version> </dependency> <dependency> <groupId>org.mobicents.servlet.sip</groupId> <artifactId>sip-servlets-core-impl</artifactId> <version>${sip.servlet.version}</version> </dependency> <!-- SIP API --> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.sip</groupId> <artifactId>jain-sip-api</artifactId> <version>1.2.1.4</version> </dependency> <!-- Logging --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.30</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency> <!-- Utilities --> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.1.1-jre</version> </dependency> </dependencies>

Web Application Configuration

web.xml

<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <display-name>Mobicents SIP Server</display-name> <!-- SIP Servlets Configuration --> <servlet> <servlet-name>sip-server</servlet-name> <servlet-class> org.mobicents.servlet.sip.startup.SipServletContextListener </servlet-class> <load-on-startup>1</load-on-startup> </servlet> <!-- SIP Servlet Mapping --> <servlet-mapping> <servlet-name>sip-server</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> <!-- Main SIP Servlet --> <servlet> <servlet-name>BasicSipServlet</servlet-name> <servlet-class>com.yourapp.sip.BasicSipServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>BasicSipServlet</servlet-name> <url-pattern>/sip/*</url-pattern> </servlet-mapping> <!-- Concurrent Utilities --> <listener> <listener-class> org.mobicents.servlet.sip.startup.SipConnectorListener </listener-class> </listener> </web-app>

sip.xml

<?xml version="1.0" encoding="UTF-8"?> <sip-app xmlns="http://www.jcp.org/xml/ns/sipservlet" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.jcp.org/xml/ns/sipservlet http://www.jcp.org/xml/ns/sipservlet/sip-app_1_1.xsd" version="1.1"> <app-name>Mobicents SIP Application</app-name> <display-name>Basic SIP Server</display-name> <servlet> <servlet-name>BasicSipServlet</servlet-name> <servlet-class>com.yourapp.sip.BasicSipServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>BasicSipServlet</servlet-name> <pattern> <equal> <var>request.method</var> <value>INVITE</value> </equal> </pattern> </servlet-mapping> <servlet-mapping> <servlet-name>BasicSipServlet</servlet-name> <pattern> <equal> <var>request.method</var> <value>BYE</value> </equal> </pattern> </servlet-mapping> <servlet-mapping> <servlet-name>BasicSipServlet</servlet-name> <pattern> <equal> <var>request.method</var> <value>REGISTER</value> </equal> </pattern> </servlet-mapping> <servlet-mapping> <servlet-name>BasicSipServlet</servlet-name> <pattern> <equal> <var>request.method</var> <value>ACK</value> </equal> </pattern> </servlet-mapping> </sip-app>

2. Basic SIP Servlet Implementation

Core SIP Servlet

package com.yourapp.sip; import org.mobicents.servlet.sip.RestcommSipServlet; import org.mobicents.servlet.sip.annotation.SipApplication; import org.mobicents.servlet.sip.annotation.SipApplicationKey; import org.mobicents.servlet.sip.annotation.SipListener; import org.mobicents.servlet.sip.message.SipFactoryImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.servlet.sip.*; import java.io.IOException; import java.text.ParseException; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @SipApplication( name = "BasicSipApplication", displayName = "Basic SIP Server Application", applicationKey = @SipApplicationKey( key = "BasicSipApp", appName = "BasicSipApplication" ) ) @SipListener public class BasicSipServlet extends SipServlet { private static final long serialVersionUID = 1L; private static final Logger logger = LoggerFactory.getLogger(BasicSipServlet.class); private SipFactory sipFactory; private Map<String, SipSession> activeSessions; private Map<String, UserRegistration> registeredUsers; @Override public void init() { this.sipFactory = (SipFactory) getServletContext().getAttribute(SIP_FACTORY); this.activeSessions = new ConcurrentHashMap<>(); this.registeredUsers = new ConcurrentHashMap<>(); logger.info("Basic SIP Servlet initialized successfully"); } @Override protected void doRegister(SipServletRequest request) throws ServletException, IOException { try { String fromUser = getUsernameFromAddress(request.getFrom().getURI().toString()); String contact = request.getAddressHeader("Contact").getURI().toString(); logger.info("REGISTER request from: {}, contact: {}", fromUser, contact); // Register user registeredUsers.put(fromUser, new UserRegistration(fromUser, contact, System.currentTimeMillis())); // Create OK response SipServletResponse response = request.createResponse(SipServletResponse.SC_OK); response.setAddressHeader("Contact", request.getAddressHeader("Contact")); response.addHeader("Expires", "3600"); response.send(); logger.info("User {} registered successfully", fromUser); } catch (Exception e) { logger.error("Error processing REGISTER request", e); request.createResponse(SipServletResponse.SC_SERVER_INTERNAL_ERROR).send(); } } @Override protected void doInvite(SipServletRequest request) throws ServletException, IOException { try { String fromUser = getUsernameFromAddress(request.getFrom().getURI().toString()); String toUser = getUsernameFromAddress(request.getTo().getURI().toString()); logger.info("INVITE request from {} to {}", fromUser, toUser); // Check if target user is registered UserRegistration targetUser = registeredUsers.get(toUser); if (targetUser == null) { logger.warn("User {} not found", toUser); request.createResponse(SipServletResponse.SC_NOT_FOUND).send(); return; } // Create provisional response SipServletResponse trying = request.createResponse(SipServletResponse.SC_TRYING); trying.send(); // Create ringing response SipServletResponse ringing = request.createResponse(SipServletResponse.SC_RINGING); ringing.send(); // Store the session String sessionId = generateSessionId(); activeSessions.put(sessionId, request.getSession()); // For demo purposes, auto-answer after 2 seconds new Thread(() -> { try { Thread.sleep(2000); SipServletResponse ok = request.createResponse(SipServletResponse.SC_OK); ok.setContent(request.getContent(), request.getContentType()); ok.send(); logger.info("Call established between {} and {}", fromUser, toUser); } catch (Exception e) { logger.error("Error establishing call", e); } }).start(); } catch (Exception e) { logger.error("Error processing INVITE request", e); request.createResponse(SipServletResponse.SC_SERVER_INTERNAL_ERROR).send(); } } @Override protected void doAck(SipServletRequest request) throws ServletException, IOException { String sessionId = request.getSession().getId(); logger.info("ACK received for session: {}", sessionId); // Call is now established // You can start media session here } @Override protected void doBye(SipServletRequest request) throws ServletException, IOException { try { String sessionId = request.getSession().getId(); logger.info("BYE request for session: {}", sessionId); // Remove session activeSessions.remove(sessionId); // Send OK response SipServletResponse response = request.createResponse(SipServletResponse.SC_OK); response.send(); logger.info("Call terminated for session: {}", sessionId); } catch (Exception e) { logger.error("Error processing BYE request", e); request.createResponse(SipServletResponse.SC_SERVER_INTERNAL_ERROR).send(); } } @Override protected void doCancel(SipServletRequest request) throws ServletException, IOException { String sessionId = request.getSession().getId(); logger.info("CANCEL request for session: {}", sessionId); // Remove session and send appropriate responses activeSessions.remove(sessionId); request.createResponse(SipServletResponse.SC_OK).send(); } @Override protected void doError(SipServletRequest request) throws ServletException, IOException { logger.error("SIP Error received: {}", request.getStatus()); logger.error("Error message: {}", request.getReasonPhrase()); } // Utility methods private String getUsernameFromAddress(String address) { if (address.contains(":")) { return address.split(":")[1].split("@")[0]; } return address.split("@")[0].replace("sip:", ""); } private String generateSessionId() { return "sess_" + System.currentTimeMillis() + "_" + Math.random(); } public Map<String, UserRegistration> getRegisteredUsers() { return new HashMap<>(registeredUsers); } public Map<String, SipSession> getActiveSessions() { return new HashMap<>(activeSessions); } @Override public void destroy() { logger.info("Basic SIP Servlet shutting down"); activeSessions.clear(); registeredUsers.clear(); super.destroy(); } }

User Registration Model

package com.yourapp.sip; import java.util.Objects; public class UserRegistration { private String username; private String contact; private long registrationTime; private long expires; public UserRegistration(String username, String contact, long registrationTime) { this.username = username; this.contact = contact; this.registrationTime = registrationTime; this.expires = registrationTime + (3600 * 1000); // 1 hour expiry } // Getters and setters public String getUsername() { return username; } public String getContact() { return contact; } public long getRegistrationTime() { return registrationTime; } public long getExpires() { return expires; } public boolean isExpired() { return System.currentTimeMillis() > expires; } public void refresh() { this.expires = System.currentTimeMillis() + (3600 * 1000); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; UserRegistration that = (UserRegistration) o; return username.equals(that.username); } @Override public int hashCode() { return Objects.hash(username); } @Override public String toString() { return String.format("UserRegistration{username='%s', contact='%s', registered=%d}", username, contact, registrationTime); } }

3. Advanced SIP Server Features

Call Routing and Management

package com.yourapp.sip; import org.mobicents.servlet.sip.RestcommSipServlet; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.servlet.sip.*; import java.io.IOException; import java.util.Map; import java.util.concurrent.*; public class AdvancedSipServlet extends RestcommSipServlet { private static final Logger logger = LoggerFactory.getLogger(AdvancedSipServlet.class); private Map<String, CallSession> activeCalls; private ScheduledExecutorService scheduler; private CallRoutingEngine routingEngine; @Override public void init() { this.activeCalls = new ConcurrentHashMap<>(); this.scheduler = Executors.newScheduledThreadPool(10); this.routingEngine = new CallRoutingEngine(); // Start session cleanup task scheduler.scheduleAtFixedRate(this::cleanupExpiredSessions, 1, 1, TimeUnit.MINUTES); logger.info("Advanced SIP Servlet initialized"); } @Override protected void doInvite(SipServletRequest request) throws ServletException, IOException { String callId = request.getCallId(); String from = request.getFrom().getURI().toString(); String to = request.getTo().getURI().toString(); logger.info("New INVITE - Call-ID: {}, From: {}, To: {}", callId, from, to); try { // Create call session CallSession callSession = new CallSession(callId, from, to); activeCalls.put(callId, callSession); // Apply call routing logic RoutingResult routing = routingEngine.routeCall(from, to); if (!routing.isRoutable()) { logger.warn("Call {} cannot be routed", callId); request.createResponse(routing.getRejectCode()).send(); activeCalls.remove(callId); return; } // Send provisional responses request.createResponse(SipServletResponse.SC_TRYING).send(); request.createResponse(SipServletResponse.SC_RINGING).send(); // Store original request for later use callSession.setOriginalRequest(request); // Process call based on routing result processCallRouting(callSession, routing); } catch (Exception e) { logger.error("Error processing INVITE for call {}", callId, e); request.createResponse(SipServletResponse.SC_SERVER_INTERNAL_ERROR).send(); activeCalls.remove(callId); } } private void processCallRouting(CallSession callSession, RoutingResult routing) { switch (routing.getRouteType()) { case DIRECT: processDirectCall(callSession); break; case IVR: processIvrCall(callSession); break; case CONFERENCE: processConferenceCall(callSession); break; case FORWARD: processForwardCall(callSession, routing.getForwardTarget()); break; default: logger.warn("Unknown route type for call {}", callSession.getCallId()); } } private void processDirectCall(CallSession callSession) { scheduler.schedule(() -> { try { SipServletRequest originalRequest = callSession.getOriginalRequest(); SipServletResponse okResponse = originalRequest.createResponse(SipServletResponse.SC_OK); // Set SDP content for media negotiation String sdpContent = createBasicSDP(); okResponse.setContent(sdpContent, "application/sdp"); okResponse.send(); callSession.setStatus(CallStatus.ESTABLISHED); logger.info("Direct call established: {}", callSession.getCallId()); } catch (Exception e) { logger.error("Error establishing direct call {}", callSession.getCallId(), e); callSession.setStatus(CallStatus.FAILED); } }, 2, TimeUnit.SECONDS); } private void processIvrCall(CallSession callSession) { // Implement IVR logic logger.info("Processing IVR call: {}", callSession.getCallId()); // Play welcome message, collect DTMF, etc. } private void processConferenceCall(CallSession callSession) { // Implement conference call logic logger.info("Processing conference call: {}", callSession.getCallId()); } private void processForwardCall(CallSession callSession, String forwardTarget) { try { SipServletRequest originalRequest = callSession.getOriginalRequest(); // Create new INVITE to forward target SipFactory sipFactory = (SipFactory) getServletContext().getAttribute(SIP_FACTORY); SipApplicationSession appSession = sipFactory.createApplicationSession(); SipServletRequest forwardRequest = sipFactory.createRequest( appSession, "INVITE", originalRequest.getFrom(), originalRequest.getTo() ); // Copy headers and content forwardRequest.setContent(originalRequest.getContent(), originalRequest.getContentType()); // Send forward request forwardRequest.send(); callSession.setStatus(CallStatus.FORWARDED); logger.info("Call {} forwarded to {}", callSession.getCallId(), forwardTarget); } catch (Exception e) { logger.error("Error forwarding call {}", callSession.getCallId(), e); callSession.setStatus(CallStatus.FAILED); } } @Override protected void doBye(SipServletRequest request) throws ServletException, IOException { String callId = request.getCallId(); logger.info("BYE received for call: {}", callId); CallSession callSession = activeCalls.remove(callId); if (callSession != null) { callSession.setStatus(CallStatus.TERMINATED); logger.info("Call {} terminated", callId); } request.createResponse(SipServletResponse.SC_OK).send(); } private String createBasicSDP() { return "v=0\r\n" + "o=user1 53655765 2353687637 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "c=IN IP4 127.0.0.1\r\n" + "t=0 0\r\n" + "m=audio 8000 RTP/AVP 0\r\n" + "a=rtpmap:0 PCMU/8000\r\n"; } private void cleanupExpiredSessions() { long currentTime = System.currentTimeMillis(); activeCalls.entrySet().removeIf(entry -> entry.getValue().isExpired(currentTime) ); } @Override public void destroy() { scheduler.shutdown(); activeCalls.clear(); logger.info("Advanced SIP Servlet destroyed"); super.destroy(); } }

Call Session Management

package com.yourapp.sip; import javax.servlet.sip.SipServletRequest; import java.util.concurrent.atomic.AtomicLong; public class CallSession { private String callId; private String from; private String to; private CallStatus status; private long createTime; private long lastActivity; private SipServletRequest originalRequest; private AtomicLong duration; public CallSession(String callId, String from, String to) { this.callId = callId; this.from = from; this.to = to; this.status = CallStatus.INITIATED; this.createTime = System.currentTimeMillis(); this.lastActivity = createTime; this.duration = new AtomicLong(0); } public enum CallStatus { INITIATED, RINGING, ESTABLISHED, FORWARDED, TERMINATED, FAILED } // Getters and setters public String getCallId() { return callId; } public String getFrom() { return from; } public String getTo() { return to; } public CallStatus getStatus() { return status; } public long getCreateTime() { return createTime; } public long getLastActivity() { return lastActivity; } public long getDuration() { return duration.get(); } public SipServletRequest getOriginalRequest() { return originalRequest; } public void setStatus(CallStatus status) { this.status = status; this.lastActivity = System.currentTimeMillis(); if (status == CallStatus.ESTABLISHED) { // Start duration tracking new Thread(() -> { while (this.status == CallStatus.ESTABLISHED) { try { Thread.sleep(1000); duration.incrementAndGet(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }).start(); } } public void setOriginalRequest(SipServletRequest request) { this.originalRequest = request; } public boolean isExpired(long currentTime) { // Consider session expired if no activity for 5 minutes return (currentTime - lastActivity) > (5 * 60 * 1000); } public void updateActivity() { this.lastActivity = System.currentTimeMillis(); } @Override public String toString() { return String.format( "CallSession{callId='%s', from='%s', to='%s', status=%s, duration=%ds}", callId, from, to, status, duration.get() ); } }

Call Routing Engine

package com.yourapp.sip; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Pattern; public class CallRoutingEngine { private Map<String, String> userExtensions; private Map<Pattern, String> routingRules; public CallRoutingEngine() { this.userExtensions = new ConcurrentHashMap<>(); this.routingRules = new ConcurrentHashMap<>(); // Initialize with sample data initializeSampleData(); } private void initializeSampleData() { // User extensions userExtensions.put("1001", "sip:[email protected]"); userExtensions.put("1002", "sip:[email protected]"); userExtensions.put("1003", "sip:[email protected]"); // Routing rules (regex pattern -> action) routingRules.put(Pattern.compile("^1800.*"), "IVR"); routingRules.put(Pattern.compile("^1900.*"), "CONFERENCE"); routingRules.put(Pattern.compile("^\\*70.*"), "CALL_FORWARD"); } public RoutingResult routeCall(String from, String to) { String toUser = extractUsername(to); logger.info("Routing call from {} to {}", from, to); // Check if target is a registered user if (userExtensions.containsKey(toUser)) { return new RoutingResult(RouteType.DIRECT, userExtensions.get(toUser)); } // Apply routing rules for (Map.Entry<Pattern, String> entry : routingRules.entrySet()) { if (entry.getKey().matcher(toUser).matches()) { return applyRoutingRule(entry.getValue(), from, to); } } // Default: reject call return new RoutingResult(false, SipServletResponse.SC_NOT_FOUND, "User not found"); } private RoutingResult applyRoutingRule(String rule, String from, String to) { switch (rule) { case "IVR": return new RoutingResult(RouteType.IVR, null); case "CONFERENCE": return new RoutingResult(RouteType.CONFERENCE, null); case "CALL_FORWARD": String forwardTarget = determineForwardTarget(from); return new RoutingResult(RouteType.FORWARD, forwardTarget); default: return new RoutingResult(false, SipServletResponse.SC_NOT_IMPLEMENTED, "Rule not implemented"); } } private String extractUsername(String sipUri) { // Extract username from SIP URI (sip:user@domain) if (sipUri.contains(":")) { return sipUri.split(":")[1].split("@")[0]; } return sipUri.split("@")[0]; } private String determineForwardTarget(String from) { // Simple forward logic - in real application, this would check user preferences String fromUser = extractUsername(from); return userExtensions.getOrDefault("1002", "sip:[email protected]"); } public void addUserExtension(String extension, String sipUri) { userExtensions.put(extension, sipUri); } public void removeUserExtension(String extension) { userExtensions.remove(extension); } public void addRoutingRule(String pattern, String action) { routingRules.put(Pattern.compile(pattern), action); } } class RoutingResult { private boolean routable; private int rejectCode; private String rejectReason; private RouteType routeType; private String forwardTarget; public RoutingResult(RouteType routeType, String forwardTarget) { this.routable = true; this.routeType = routeType; this.forwardTarget = forwardTarget; } public RoutingResult(boolean routable, int rejectCode, String rejectReason) { this.routable = routable; this.rejectCode = rejectCode; this.rejectReason = rejectReason; } // Getters public boolean isRoutable() { return routable; } public int getRejectCode() { return rejectCode; } public String getRejectReason() { return rejectReason; } public RouteType getRouteType() { return routeType; } public String getForwardTarget() { return forwardTarget; } } enum RouteType { DIRECT, IVR, CONFERENCE, FORWARD, REJECT }

4. SIP Server Configuration

Server Configuration Class

package com.yourapp.sip.config; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class SipServerConfig { private static final Logger logger = LoggerFactory.getLogger(SipServerConfig.class); private static final String CONFIG_FILE = "/sip-server.properties"; private static SipServerConfig instance; private Properties properties; private SipServerConfig() { loadConfiguration(); } public static synchronized SipServerConfig getInstance() { if (instance == null) { instance = new SipServerConfig(); } return instance; } private void loadConfiguration() { properties = new Properties(); try (InputStream input = getClass().getResourceAsStream(CONFIG_FILE)) { if (input != null) { properties.load(input); logger.info("SIP server configuration loaded successfully"); } else { logger.warn("Configuration file not found, using defaults"); setDefaultProperties(); } } catch (IOException e) { logger.error("Error loading configuration file", e); setDefaultProperties(); } } private void setDefaultProperties() { properties.setProperty("sip.server.host", "127.0.0.1"); properties.setProperty("sip.server.port", "5060"); properties.setProperty("sip.server.transport", "udp"); properties.setProperty("sip.session.timeout", "300"); properties.setProperty("sip.registration.expires", "3600"); properties.setProperty("sip.max.calls", "100"); properties.setProperty("sip.audio.port.range.start", "8000"); properties.setProperty("sip.audio.port.range.end", "8100"); } public String getProperty(String key) { return properties.getProperty(key); } public String getProperty(String key, String defaultValue) { return properties.getProperty(key, defaultValue); } public int getIntProperty(String key, int defaultValue) { try { return Integer.parseInt(properties.getProperty(key)); } catch (NumberFormatException e) { return defaultValue; } } public boolean getBooleanProperty(String key, boolean defaultValue) { String value = properties.getProperty(key); if (value != null) { return Boolean.parseBoolean(value); } return defaultValue; } // Configuration getters public String getServerHost() { return getProperty("sip.server.host", "127.0.0.1"); } public int getServerPort() { return getIntProperty("sip.server.port", 5060); } public String getTransport() { return getProperty("sip.server.transport", "udp"); } public int getSessionTimeout() { return getIntProperty("sip.session.timeout", 300); } public int getMaxCalls() { return getIntProperty("sip.max.calls", 100); } }

Configuration Properties File

# sip-server.properties sip.server.host=192.168.1.100 sip.server.port=5060 sip.server.transport=udp sip.server.domain=yourdomain.com # Session settings sip.session.timeout=300 sip.registration.expires=3600 sip.max.calls=100 # Audio settings sip.audio.port.range.start=8000 sip.audio.port.range.end=8100 sip.audio.codec.preference=PCMU,PCMA,G729 # Logging sip.log.level=INFO sip.log.requests=true sip.log.responses=true # Security sip.auth.enabled=true sip.auth.realm=YourSIPRealm sip.auth.nonce.expiry=300 # Performance sip.thread.pool.size=50 sip.queue.size=1000 sip.timer.interval=1000

5. Monitoring and Management

SIP Server Monitor

package com.yourapp.sip.monitor; import com.yourapp.sip.AdvancedSipServlet; import com.yourapp.sip.CallSession; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.management.*; import java.lang.management.ManagementFactory; import java.util.Map; import java.util.concurrent.atomic.AtomicLong; public class SipServerMonitor implements SipServerMonitorMBean { private static final Logger logger = LoggerFactory.getLogger(SipServerMonitor.class); private AdvancedSipServlet sipServlet; private AtomicLong totalCalls; private AtomicLong successfulCalls; private AtomicLong failedCalls; private AtomicLong totalRegistrations; public SipServerMonitor(AdvancedSipServlet sipServlet) { this.sipServlet = sipServlet; this.totalCalls = new AtomicLong(0); this.successfulCalls = new AtomicLong(0); this.failedCalls = new AtomicLong(0); this.totalRegistrations = new AtomicLong(0); registerMBean(); } private void registerMBean() { try { MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); ObjectName name = new ObjectName("com.yourapp.sip:type=SipServerMonitor"); mbs.registerMBean(this, name); logger.info("SIP Server Monitor MBean registered successfully"); } catch (Exception e) { logger.error("Failed to register MBean", e); } } // MBean interface implementation @Override public long getTotalCalls() { return totalCalls.get(); } @Override public long getSuccessfulCalls() { return successfulCalls.get(); } @Override public long getFailedCalls() { return failedCalls.get(); } @Override public long getActiveCalls() { return sipServlet.getActiveCalls().size(); } @Override public long getTotalRegistrations() { return totalRegistrations.get(); } @Override public int getRegisteredUsers() { return sipServlet.getRegisteredUsers().size(); } @Override public double getCallSuccessRate() { long total = totalCalls.get(); if (total == 0) return 0.0; return (successfulCalls.get() * 100.0) / total; } @Override public String getServerStatus() { return "RUNNING"; } @Override public Map<String, CallSession> getActiveCallDetails() { return sipServlet.getActiveCalls(); } @Override public void resetStatistics() { totalCalls.set(0); successfulCalls.set(0); failedCalls.set(0); totalRegistrations.set(0); } // Methods to update statistics public void incrementTotalCalls() { totalCalls.incrementAndGet(); } public void incrementSuccessfulCalls() { successfulCalls.incrementAndGet(); } public void incrementFailedCalls() { failedCalls.incrementAndGet(); } public void incrementRegistrations() { totalRegistrations.incrementAndGet(); } } // MBean Interface public interface SipServerMonitorMBean { long getTotalCalls(); long getSuccessfulCalls(); long getFailedCalls(); long getActiveCalls(); long getTotalRegistrations(); int getRegisteredUsers(); double getCallSuccessRate(); String getServerStatus(); Map<String, CallSession> getActiveCallDetails(); void resetStatistics(); }

6. Deployment and Testing

Main Application Class

package com.yourapp.sip; import org.mobicents.servlet.sip.startup.SipServletContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.servlet.ServletContextEvent; public class SipServerApplication extends SipServletContextListener { private static final Logger logger = LoggerFactory.getLogger(SipServerApplication.class); @Override public void contextInitialized(ServletContextEvent sce) { logger.info("Starting Mobicents SIP Server Application"); try { // Initialize configuration SipServerConfig config = SipServerConfig.getInstance(); // Log startup information logger.info("SIP Server Configuration:"); logger.info(" Host: {}", config.getServerHost()); logger.info(" Port: {}", config.getServerPort()); logger.info(" Transport: {}", config.getTransport()); logger.info(" Max Calls: {}", config.getMaxCalls()); super.contextInitialized(sce); logger.info("Mobicents SIP Server Application started successfully"); } catch (Exception e) { logger.error("Failed to start SIP Server Application", e); throw new RuntimeException("SIP Server initialization failed", e); } } @Override public void contextDestroyed(ServletContextEvent sce) { logger.info("Stopping Mobicents SIP Server Application"); try { super.contextDestroyed(sce); logger.info("Mobicents SIP Server Application stopped successfully"); } catch (Exception e) { logger.error("Error during SIP Server shutdown", e); } } }

Key Features Covered:

Basic SIP Servlet - Handling REGISTER, INVITE, BYE requests
Call Management - Session tracking and call state management
Call Routing - Advanced routing logic with multiple route types
Configuration Management - External configuration support
Monitoring - JMX monitoring and statistics
User Registration - SIP user management and authentication

This comprehensive Mobicents SIP server implementation provides a solid foundation for building VoIP applications, call centers, IVR systems, and other real-time communication solutions.