Fix #3: RTC listen endpoint issue.

Author: ossrs-ai

api.go

@@ -101,11 +101,13 @@ func (v *srsHTTPAPIServer) Run(ctx context.Context) error {
 
 		err := v.server.ListenAndServe()
 		if err != nil {
-			if ctx.Err() != context.Canceled {
+			if err == http.ErrServerClosed {
+				logger.Df(ctx, "HTTP API server done")
+			} else if ctx.Err() != nil {
+				logger.Df(ctx, "HTTP API server done with context canceled")
+			} else {
 				// TODO: If HTTP API server closed unexpectedly, we should notice the main loop to quit.
 				logger.Wf(ctx, "HTTP API accept err %+v", err)
-			} else {
-				logger.Df(ctx, "HTTP API server done")
 			}
 		}
 	}()
@@ -259,11 +261,13 @@ func (v *systemAPI) Run(ctx context.Context) error {
 
 		err := v.server.ListenAndServe()
 		if err != nil {
-			if ctx.Err() != context.Canceled {
+			if err == http.ErrServerClosed {
+				logger.Df(ctx, "System API server done")
+			} else if ctx.Err() != nil {
+				logger.Df(ctx, "System API server done with context canceled")
+			} else {
 				// TODO: If System API server closed unexpectedly, we should notice the main loop to quit.
 				logger.Wf(ctx, "System API accept err %+v", err)
-			} else {
-				logger.Df(ctx, "System API server done")
 			}
 		}
 	}()

env.go

@@ -80,8 +80,8 @@ func buildDefaultEnvironmentVariables(ctx context.Context) {
 	setEnvDefault("PROXY_SRT_SERVER", "20080")
 	// The API server of proxy itself.
 	setEnvDefault("PROXY_SYSTEM_API", "12025")
-	// The static directory for web server.
-	setEnvDefault("PROXY_STATIC_FILES", "../trunk/research")
+	// The static directory for web server, optional.
+	setEnvDefault("PROXY_STATIC_FILES", "")
 
 	// The load balancer, use redis or memory.
 	setEnvDefault("PROXY_LOAD_BALANCER_TYPE", "memory")

http.go

@@ -162,11 +162,13 @@ func (v *srsHTTPStreamServer) Run(ctx context.Context) error {
 
 		err := v.server.ListenAndServe()
 		if err != nil {
-			if ctx.Err() != context.Canceled {
+			if err == http.ErrServerClosed {
+				logger.Df(ctx, "HTTP Stream server done")
+			} else if ctx.Err() != nil {
+				logger.Df(ctx, "HTTP Stream server done with context canceled")
+			} else {
 				// TODO: If HTTP Stream server closed unexpectedly, we should notice the main loop to quit.
 				logger.Wf(ctx, "HTTP Stream accept err %+v", err)
-			} else {
-				logger.Df(ctx, "HTTP Stream server done")
 			}
 		}
 	}()

rtc.go

@@ -258,6 +258,11 @@ func (v *srsWebRTCServer) Run(ctx context.Context) error {
 			buf := make([]byte, 4096)
 			n, caddr, err := listener.ReadFromUDP(buf)
 			if err != nil {
+				// If context is canceled or connection is closed, exit gracefully without logging error.
+				if ctx.Err() != nil || isClosedNetworkError(err) {
+					logger.Df(ctx, "WebRTC server done")
+					return
+				}
 				// TODO: If WebRTC server closed unexpectedly, we should notice the main loop to quit.
 				logger.Wf(ctx, "WebRTC read from udp failed, err=%+v", err)
 				time.Sleep(1 * time.Second)

rtmp.go

@@ -74,11 +74,12 @@ func (v *srsRTMPServer) Run(ctx context.Context) error {
 		for {
 			conn, err := v.listener.AcceptTCP()
 			if err != nil {
-				if ctx.Err() != context.Canceled {
+				// If context is canceled or connection is closed, exit gracefully without logging error.
+				if ctx.Err() != nil || isClosedNetworkError(err) {
+					logger.Df(ctx, "RTMP server done")
+				} else {
 					// TODO: If RTMP server closed unexpectedly, we should notice the main loop to quit.
 					logger.Wf(ctx, "RTMP server accept err %+v", err)
-				} else {
-					logger.Df(ctx, "RTMP server done")
 				}
 				return
 			}

srt.go

@@ -82,6 +82,11 @@ func (v *srsSRTServer) Run(ctx context.Context) error {
 			buf := make([]byte, 4096)
 			n, caddr, err := v.listener.ReadFromUDP(buf)
 			if err != nil {
+				// If context is canceled or connection is closed, exit gracefully without logging error.
+				if ctx.Err() != nil || isClosedNetworkError(err) {
+					logger.Df(ctx, "SRT server done")
+					return
+				}
 				// TODO: If SRT server closed unexpectedly, we should notice the main loop to quit.
 				logger.Wf(ctx, "SRT read from udp failed, err=%+v", err)
 				time.Sleep(1 * time.Second)

utils.go

@@ -45,7 +45,7 @@ func apiError(ctx context.Context, w http.ResponseWriter, r *http.Request, err e
 	logger.Wf(ctx, "HTTP API error %+v", err)
 	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 	w.WriteHeader(http.StatusInternalServerError)
-	fmt.Fprintln(w, fmt.Sprintf("%v", err))
+	fmt.Fprintf(w, "%v\n", err)
 }
 
 func apiCORS(ctx context.Context, w http.ResponseWriter, r *http.Request) bool {
@@ -142,6 +142,20 @@ func isPeerClosedError(err error) bool {
 	return false
 }
 
+// isClosedNetworkError indicates whether the error is due to a closed network connection.
+func isClosedNetworkError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	// Check for "use of closed network connection" error
+	if netErr, ok := err.(*net.OpError); ok {
+		return netErr.Err.Error() == "use of closed network connection"
+	}
+
+	return false
+}
+
 // convertURLToStreamURL convert the URL in HTTP request to special URLs. The unifiedURL is the URL
 // in unified, foramt as scheme://vhost/app/stream without extensions. While the fullURL is the unifiedURL
 // with extension.
@@ -263,7 +277,44 @@ func parseListenEndpoint(ep string) (protocol string, ip net.IP, port uint16, er
 		}
 	}
 
-	// Must be protocol://ip:port schema.
+	// Handle URL-style format: protocol://host:port or protocol://port
+	if strings.Contains(ep, "://") {
+		parts := strings.SplitN(ep, "://", 2)
+		if len(parts) != 2 {
+			return "", nil, 0, errors.Errorf("invalid endpoint %v", ep)
+		}
+
+		protocol = parts[0]
+		hostPort := parts[1]
+
+		// Check if there's a port specified
+		if strings.Contains(hostPort, ":") {
+			// Format: protocol://host:port
+			host, portStr, err := net.SplitHostPort(hostPort)
+			if err != nil {
+				return "", nil, 0, errors.Wrapf(err, "parse host:port %v", hostPort)
+			}
+
+			p, err := strconv.Atoi(portStr)
+			if err != nil {
+				return "", nil, 0, errors.Wrapf(err, "parse port %v", portStr)
+			}
+
+			if host != "" {
+				ip = net.ParseIP(host)
+			}
+			return protocol, ip, uint16(p), nil
+		} else {
+			// Format: protocol://port
+			p, err := strconv.Atoi(hostPort)
+			if err != nil {
+				return "", nil, 0, errors.Wrapf(err, "parse port %v", hostPort)
+			}
+			return protocol, nil, uint16(p), nil
+		}
+	}
+
+	// Legacy format: protocol:ip:port
 	parts := strings.Split(ep, ":")
 	if len(parts) != 3 {
 		return "", nil, 0, errors.Errorf("invalid endpoint %v", ep)